--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1541,16 +1541,24 @@ version = "0.0.1"
name = "proc-macro2"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
+name = "proc-macro2"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
name = "procedural-masquerade"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "pulse"
version = "0.2.0"
dependencies = [
@@ -1579,16 +1587,24 @@ source = "registry+https://github.com/ru
name = "quote"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
+name = "quote"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
name = "rand"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"fuchsia-zircon 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.39 (registry+https://github.com/rust-lang/crates.io-index)",
]
@@ -1942,40 +1958,32 @@ dependencies = [
"size_of_test 0.0.1",
"smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"style 0.0.1",
"style_traits 0.0.1",
]
[[package]]
name = "syn"
-version = "0.11.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "synom 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "syn"
version = "0.12.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
-name = "synom"
-version = "0.11.2"
+name = "syn"
+version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
- "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.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.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2163,21 +2171,16 @@ source = "registry+https://github.com/ru
[[package]]
name = "unicode-width"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "unicode-xid"
-version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unicode-xid"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "unreachable"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
@@ -2422,18 +2425,18 @@ dependencies = [
"xpcom 0.1.0",
]
[[package]]
name = "xpcom_macros"
version = "0.1.0"
dependencies = [
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "yaml-rust"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"linked-hash-map 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2596,20 +2599,22 @@ dependencies = [
"checksum phf_codegen 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "d62594c0bb54c464f633175d502038177e90309daf2e0158be42ed5f023ce88f"
"checksum phf_generator 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "6b07ffcc532ccc85e3afc45865469bf5d9e4ef5bfcf9622e3cfe80c2d275ec03"
"checksum phf_shared 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "07e24b0ca9643bdecd0632f2b3da6b1b89bbb0030e0b992afc1113b23a7bc2f2"
"checksum pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "3a8b4c6b8165cd1a1cd4b9b120978131389f64bdaf456435caa41e630edba903"
"checksum plane-split 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "69c557e11e3a1533bc969fa596e5011e1d9f76dd61cd102ef942c9f8654b17a2"
"checksum podio 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e5422a1ee1bc57cc47ae717b0137314258138f38fd5f3cea083f43a9725383a0"
"checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
"checksum proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d1cb7aaaa4bf022ec2b14ff2f2ba1643a22f3cee88df014a85e14b392282c61d"
+"checksum proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "49b6a521dc81b643e9a51e0d1cf05df46d5a2f3c0280ea72bcb68276ba64a118"
"checksum procedural-masquerade 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9f566249236c6ca4340f7ca78968271f0ed2b0f234007a61b66f9ecd0af09260"
"checksum quick-error 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eda5fe9b71976e62bc81b781206aaa076401769b2143379d3eb2118388babac4"
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
"checksum quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1eca14c727ad12702eb4b6bfb5a232287dcf8385cb8ca83a3eeaf6519c44c408"
+"checksum quote 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7b0ff51282f28dc1b53fd154298feaa2e77c5ea0dba68e1fd8b03b72fbe13d2a"
"checksum rand 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)" = "6475140dfd8655aeb72e1fd4b7a1cc1c202be65d71669476e392fe62532b9edd"
"checksum rayon 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "485541959c8ecc49865526fe6c4de9653dd6e60d829d6edf0be228167b60372d"
"checksum rayon-core 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9d24ad214285a7729b174ed6d3bcfcb80177807f959d95fafd5bfc5c4f201ac8"
"checksum redox_syscall 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "ab105df655884ede59d45b7070c8a65002d921461ee813a024558ca16030eea0"
"checksum regex 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1731164734096285ec2a5ec7fea5248ae2f5485b3feeb0115af4fda2183b2d1b"
"checksum regex-syntax 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad890a5eef7953f55427c50575c680c42841653abd2b028b68cd223d157f62db"
"checksum ron 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "da06feaa07f69125ab9ddc769b11de29090122170b402547f64b86fe16ebc399"
"checksum runloop 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d79b4b604167921892e84afbbaad9d5ad74e091bf6c511d9dbfb0593f09fabd"
@@ -2630,19 +2635,18 @@ dependencies = [
"checksum slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17b4fcaed89ab08ef143da37bc52adbcc04d4a69014f4c1208d6b51f0c47bc23"
"checksum smallbitvec 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "79b776f00dfe01df905fa3b2eaa1659522e99e3fc4a7b1334171622205c4bdcf"
"checksum smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "44db0ecb22921ef790d17ae13a3f6d15784183ff5f2a01aa32098c7498d2b4b9"
"checksum stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "15132e0e364248108c5e2c02e3ab539be8d6f5d52a01ca9bbf27ed657316f02b"
"checksum string_cache 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "39cb4173bcbd1319da31faa5468a7e3870683d7a237150b0b0aaafd546f6ad12"
"checksum string_cache_codegen 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "479cde50c3539481f33906a387f2bd17c8e87cb848c35b6021d41fb81ff9b4d7"
"checksum string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b1884d1bc09741d466d9b14e6d37ac89d6909cbcac41dd9ae982d4d063bbedfc"
"checksum strsim 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d15c810519a91cf877e7e36e63fe068815c678181439f2f29e2562147c3694"
-"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9e1c669ed757c0ebd04337f6a5bb972d05e0c08fe2540dd3ee3dd9e4daf1604c"
-"checksum synom 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)" = "27e31aa4b09b9f4cb12dff3c30ba503e17b1a624413d764d32dab76e3920e5bc"
+"checksum syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "91b52877572087400e83d24b9178488541e3d535259e04ff17a63df1e5ceff59"
"checksum synstructure 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "010366096045d8250555904c58da03377289e7f4b2ce7a5b1027e2b532f41000"
"checksum tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "87974a6f5c1dfb344d733055601650059a3363de2a6104819293baff662132d6"
"checksum term 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "fa63644f74ce96fbeb9b794f66aff2a52d601cbd5e80f4b97123e3899f4570f1"
"checksum term_size 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2b6b55df3198cc93372e85dd2ed817f0e38ce8cc0f22eb32391bfad9c4bf209"
"checksum termcolor 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "adc4587ead41bf016f11af03e55a624c06568b5a19db4e90fde573d805074f83"
"checksum textwrap 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c0b59b6b4b44d867f1370ef1bd91bfb262bf07bf0ae65c202ea2fbc16153b693"
"checksum thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "279ef31c19ededf577bfd12dfae728040a21f635b06a24cd670ff510edd38963"
"checksum thread_profiler 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf947d192a9be60ef5131cc7a4648886ba89d712f16700ebbf80c8a69d05d48f"
@@ -2654,17 +2658,16 @@ dependencies = [
"checksum traitobject 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "efd1f82c56340fdf16f2a953d7bda4f8fdffba13d93b00844c25572110b26079"
"checksum typeable 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1410f6f91f21d1612654e7cc69193b0334f909dcf2c790c4826254fbb86f8887"
"checksum uluru 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "519130f0ea964ba540a9d8af1373738c2226f1d465eda07e61db29feb5479db9"
"checksum unicase 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7f4765f83163b74f957c797ad9253caf97f103fb064d3999aea9568d09fc8a33"
"checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
"checksum unicode-normalization 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "51ccda9ef9efa3f7ef5d91e8f9b83bbe6955f9bf86aec89d5cce2c874625920f"
"checksum unicode-segmentation 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "18127285758f0e2c6cf325bb3f3d138a12fee27de4f23e146cd6a179f26c2cf3"
"checksum unicode-width 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bf3a113775714a22dcb774d8ea3655c53a32debae63a063acc00a91cc586245f"
-"checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
"checksum unreachable 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1f2ae5ddb18e1c92664717616dd9549dde73f539f01bd7b77c2edb2446bdff91"
"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
"checksum url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fa35e768d4daf1d85733418a49fb42e10d7f633e394fccab4ab7aba897053fe2"
"checksum utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "662fab6525a98beff2921d7f61a39e7d59e0b425ebc7d0d9e66d316e55124122"
"checksum uuid 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "78c590b5bd79ed10aad8fb75f078a59d8db445af6c743e55c4a53227fc01c13f"
"checksum vcpkg 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9e0a7d8bed3178a8fb112199d466eeca9ed09a14ba8ad67718179b4fd5487d0b"
"checksum vec_map 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "887b5b631c2ad01628bbbaa7dd4c869f80d3186688f8d0b6f58774fbe324988c"
copy from third_party/rust/proc-macro2/.cargo-checksum.json
copy to third_party/rust/proc-macro2-0.2.2/.cargo-checksum.json
copy from third_party/rust/proc-macro2/.travis.yml
copy to third_party/rust/proc-macro2-0.2.2/.travis.yml
copy from third_party/rust/proc-macro2/Cargo.toml
copy to third_party/rust/proc-macro2-0.2.2/Cargo.toml
rename from third_party/rust/syn-0.11.11/LICENSE-APACHE
rename to third_party/rust/proc-macro2-0.2.2/LICENSE-APACHE
new file mode 100644
--- /dev/null
+++ b/third_party/rust/proc-macro2-0.2.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 Alex Crichton
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
copy from third_party/rust/proc-macro2/README.md
copy to third_party/rust/proc-macro2-0.2.2/README.md
copy from third_party/rust/proc-macro2/src/lib.rs
copy to third_party/rust/proc-macro2-0.2.2/src/lib.rs
rename from third_party/rust/proc-macro2/src/macros.rs
rename to third_party/rust/proc-macro2-0.2.2/src/macros.rs
copy from third_party/rust/proc-macro2/src/stable.rs
copy to third_party/rust/proc-macro2-0.2.2/src/stable.rs
copy from third_party/rust/proc-macro2/src/strnom.rs
copy to third_party/rust/proc-macro2-0.2.2/src/strnom.rs
copy from third_party/rust/proc-macro2/src/unstable.rs
copy to third_party/rust/proc-macro2-0.2.2/src/unstable.rs
copy from third_party/rust/proc-macro2/tests/test.rs
copy to third_party/rust/proc-macro2-0.2.2/tests/test.rs
--- a/third_party/rust/proc-macro2/.cargo-checksum.json
+++ b/third_party/rust/proc-macro2/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".travis.yml":"e455a0ed5c3dd056d31f4c7be088bc94f21cab6595a23f2f015b1efc0ac2b55c","Cargo.toml":"0b700f1e7b8ba76ce4678d36b6906d38455e88f51085ea9f120d6ca63f13d5d7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"adf2e822923878c2ebf4a0a782898c598fc6f57a3af905b85d57fc716c836687","src/lib.rs":"fbae25504264b185d877fb8784d4d88333ea34a7cbeddca3277dc8421f179933","src/macros.rs":"414505e520b8d705b4ce5a64ec2e82d6d1af0b88567454169486a668fbc1e9c8","src/stable.rs":"6363c4c0ef989c2ec81aa75be71c69a103d45a1de439f3f3bcb6806d8a78a172","src/strnom.rs":"1baded8543a9930798fb16092fe51e9074591902e327e0f94eb1c908a6370de9","src/unstable.rs":"110d27103e37427b3d1dcb45b6ba9dc9f5641a255766a43d5db0f4fd10a341ed","tests/test.rs":"9e75d5289abc1dc58c1df00ae051d8c3cd2c0d7830cca5ad689007c05acffe26"},"package":"d1cb7aaaa4bf022ec2b14ff2f2ba1643a22f3cee88df014a85e14b392282c61d"}
\ No newline at end of file
+{"files":{".travis.yml":"872a0d195dcb1e84f28aa994f301c7139f70360bb42dee3954df5ee965efea15","Cargo.toml":"6ed5d7b9bf8805abd76f9e2a9be99b98e2cb70d9b97980b8aa09b6082d26a94d","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"ce05336717e1e90724491a2f54487c41c752fa2d32396639439f7c6d0f1e6776","src/lib.rs":"e99fedcb4b410c626fe1a3ab722c8b4f98baed2c64c2dff28c4eb62da354f2e2","src/stable.rs":"fd8d86f7542d211030056a7cdcc58b86131180d54f461910a4a067269eee9d4a","src/strnom.rs":"129fe22f0b50e5a64fca82e731c959135381c910e19f3305ef35420e0aadde08","src/unstable.rs":"b43c713ac16d9de0ba0fa1b9bebe390122b4ad60ef2fc75408f721305fdcd46b","tests/test.rs":"a8229931093cd6b39f759c60ef097e59bc43c98f1b0e5eea06ecc8d5d0879853"},"package":"49b6a521dc81b643e9a51e0d1cf05df46d5a2f3c0280ea72bcb68276ba64a118"}
\ No newline at end of file
--- a/third_party/rust/proc-macro2/.travis.yml
+++ b/third_party/rust/proc-macro2/.travis.yml
@@ -7,16 +7,17 @@ matrix:
- rust: stable
- rust: beta
- rust: nightly
before_script:
- pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
script:
- cargo test
- cargo build --features nightly
+ - cargo build --no-default-features
- RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo test
- RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build --features nightly
- RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo doc --no-deps
after_success:
- travis-cargo --only nightly doc-upload
script:
- cargo test
--- a/third_party/rust/proc-macro2/Cargo.toml
+++ b/third_party/rust/proc-macro2/Cargo.toml
@@ -7,25 +7,27 @@
#
# If you believe there's an error in this file please file an
# issue against the rust-lang/cargo repository. If you're
# editing this file be aware that the upstream Cargo.toml
# will likely look very different (and much more reasonable)
[package]
name = "proc-macro2"
-version = "0.2.2"
+version = "0.3.6"
authors = ["Alex Crichton <alex@alexcrichton.com>"]
description = "A stable implementation of the upcoming new `proc_macro` API. Comes with an\noption, off by default, to also reimplement itself in terms of the upstream\nunstable API.\n"
homepage = "https://github.com/alexcrichton/proc-macro2"
documentation = "https://docs.rs/proc-macro2"
readme = "README.md"
keywords = ["macros"]
license = "MIT/Apache-2.0"
repository = "https://github.com/alexcrichton/proc-macro2"
[lib]
doctest = false
[dependencies.unicode-xid]
version = "0.1"
[features]
-nightly = []
+default = ["proc-macro"]
+nightly = ["proc-macro"]
+proc-macro = []
--- a/third_party/rust/proc-macro2/README.md
+++ b/third_party/rust/proc-macro2/README.md
@@ -22,17 +22,17 @@ the real `proc_macro` crate once the sup
## Usage
This crate by default compiles on the stable version of the compiler. It only
uses the stable surface area of the `proc_macro` crate upstream in the compiler
itself. Usage is done via:
```toml
[dependencies]
-proc-macro2 = "0.2"
+proc-macro2 = "0.3"
```
followed by
```rust
extern crate proc_macro;
extern crate proc_macro2;
@@ -52,17 +52,17 @@ If you'd like you can enable the `nightl
cause it to compile against the **unstable and nightly-only** features of the
`proc_macro` crate. This in turn requires a nightly compiler. This should help
preserve span information, however, coming in from the compiler itself.
You can enable this feature via:
```toml
[dependencies]
-proc-macro2 = { version = "0.2", features = ["nightly"] }
+proc-macro2 = { version = "0.3", features = ["nightly"] }
```
## Unstable Features
`proc-macro2` supports exporting some methods from `proc_macro` which are
currently highly unstable, and may not be stabilized in the first pass of
`proc_macro` stabilizations. These features are not exported by default. Minor
--- a/third_party/rust/proc-macro2/src/lib.rs
+++ b/third_party/rust/proc-macro2/src/lib.rs
@@ -1,113 +1,135 @@
-//! A "shim crate" intended to multiplex the `proc_macro` API on to stable Rust.
+//! A "shim crate" intended to multiplex the [`proc_macro`] API on to stable
+//! Rust.
//!
//! Procedural macros in Rust operate over the upstream
-//! `proc_macro::TokenStream` type. This type currently is quite conservative
-//! and exposed no internal implementation details. Nightly compilers, however,
-//! contain a much richer interface. This richer interface allows fine-grained
-//! inspection of the token stream which avoids stringification/re-lexing and
-//! also preserves span information.
+//! [`proc_macro::TokenStream`][ts] type. This type currently is quite
+//! conservative and exposed no internal implementation details. Nightly
+//! compilers, however, contain a much richer interface. This richer interface
+//! allows fine-grained inspection of the token stream which avoids
+//! stringification/re-lexing and also preserves span information.
//!
-//! The upcoming APIs added to `proc_macro` upstream are the foundation for
+//! The upcoming APIs added to [`proc_macro`] upstream are the foundation for
//! productive procedural macros in the ecosystem. To help prepare the ecosystem
//! for using them this crate serves to both compile on stable and nightly and
//! mirrors the API-to-be. The intention is that procedural macros which switch
//! to use this crate will be trivially able to switch to the upstream
//! `proc_macro` crate once its API stabilizes.
//!
//! In the meantime this crate also has a `nightly` Cargo feature which
-//! enables it to reimplement itself with the unstable API of `proc_macro`.
+//! enables it to reimplement itself with the unstable API of [`proc_macro`].
//! This'll allow immediate usage of the beneficial upstream API, particularly
//! around preserving span information.
+//!
+//! [`proc_macro`]: https://doc.rust-lang.org/proc_macro/
+//! [ts]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
// Proc-macro2 types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/proc-macro2/0.2.2")]
-
+#![doc(html_root_url = "https://docs.rs/proc-macro2/0.3.6")]
#![cfg_attr(feature = "nightly", feature(proc_macro))]
+#[cfg(feature = "proc-macro")]
extern crate proc_macro;
#[cfg(not(feature = "nightly"))]
extern crate unicode_xid;
use std::fmt;
+use std::iter::FromIterator;
+use std::marker;
+use std::rc::Rc;
use std::str::FromStr;
-use std::iter::FromIterator;
#[macro_use]
#[cfg(not(feature = "nightly"))]
mod strnom;
#[path = "stable.rs"]
#[cfg(not(feature = "nightly"))]
mod imp;
#[path = "unstable.rs"]
#[cfg(feature = "nightly")]
mod imp;
-#[macro_use]
-mod macros;
+#[derive(Clone)]
+pub struct TokenStream {
+ inner: imp::TokenStream,
+ _marker: marker::PhantomData<Rc<()>>,
+}
+
+pub struct LexError {
+ inner: imp::LexError,
+ _marker: marker::PhantomData<Rc<()>>,
+}
-#[derive(Clone)]
-pub struct TokenStream(imp::TokenStream);
+impl TokenStream {
+ fn _new(inner: imp::TokenStream) -> TokenStream {
+ TokenStream {
+ inner: inner,
+ _marker: marker::PhantomData,
+ }
+ }
-pub struct LexError(imp::LexError);
+ pub fn empty() -> TokenStream {
+ TokenStream::_new(imp::TokenStream::empty())
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.inner.is_empty()
+ }
+}
impl FromStr for TokenStream {
type Err = LexError;
fn from_str(src: &str) -> Result<TokenStream, LexError> {
- match src.parse() {
- Ok(e) => Ok(TokenStream(e)),
- Err(e) => Err(LexError(e)),
- }
+ let e = src.parse().map_err(|e| LexError {
+ inner: e,
+ _marker: marker::PhantomData,
+ })?;
+ Ok(TokenStream::_new(e))
}
}
+#[cfg(feature = "proc-macro")]
impl From<proc_macro::TokenStream> for TokenStream {
fn from(inner: proc_macro::TokenStream) -> TokenStream {
- TokenStream(inner.into())
+ TokenStream::_new(inner.into())
}
}
+#[cfg(feature = "proc-macro")]
impl From<TokenStream> for proc_macro::TokenStream {
fn from(inner: TokenStream) -> proc_macro::TokenStream {
- inner.0.into()
+ inner.inner.into()
}
}
-impl From<TokenTree> for TokenStream {
- fn from(tree: TokenTree) -> TokenStream {
- TokenStream(tree.into())
- }
-}
-
-impl<T: Into<TokenStream>> FromIterator<T> for TokenStream {
- fn from_iter<I: IntoIterator<Item = T>>(streams: I) -> Self {
- TokenStream(streams.into_iter().map(|t| t.into().0).collect())
+impl FromIterator<TokenTree> for TokenStream {
+ fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
+ TokenStream::_new(streams.into_iter().collect())
}
}
-impl IntoIterator for TokenStream {
- type Item = TokenTree;
- type IntoIter = TokenTreeIter;
-
- fn into_iter(self) -> TokenTreeIter {
- TokenTreeIter(self.0.into_iter())
+impl fmt::Display for TokenStream {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
}
}
-impl TokenStream {
- pub fn empty() -> TokenStream {
- TokenStream(imp::TokenStream::empty())
+impl fmt::Debug for TokenStream {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
}
+}
- pub fn is_empty(&self) -> bool {
- self.0.is_empty()
+impl fmt::Debug for LexError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
}
}
// Returned by reference, so we can't easily wrap it.
#[cfg(procmacro2_semver_exempt)]
pub use imp::FileName;
#[cfg(procmacro2_semver_exempt)]
@@ -142,196 +164,427 @@ impl fmt::Debug for SourceFile {
#[cfg(procmacro2_semver_exempt)]
pub struct LineColumn {
pub line: usize,
pub column: usize,
}
#[derive(Copy, Clone)]
-pub struct Span(imp::Span);
+pub struct Span {
+ inner: imp::Span,
+ _marker: marker::PhantomData<Rc<()>>,
+}
impl Span {
- pub fn call_site() -> Span {
- Span(imp::Span::call_site())
+ fn _new(inner: imp::Span) -> Span {
+ Span {
+ inner: inner,
+ _marker: marker::PhantomData,
+ }
}
+ pub fn call_site() -> Span {
+ Span::_new(imp::Span::call_site())
+ }
+
+ #[cfg(procmacro2_semver_exempt)]
pub fn def_site() -> Span {
- Span(imp::Span::def_site())
+ Span::_new(imp::Span::def_site())
}
/// Creates a new span with the same line/column information as `self` but
/// that resolves symbols as though it were at `other`.
+ #[cfg(procmacro2_semver_exempt)]
pub fn resolved_at(&self, other: Span) -> Span {
- Span(self.0.resolved_at(other.0))
+ Span::_new(self.inner.resolved_at(other.inner))
}
/// Creates a new span with the same name resolution behavior as `self` but
/// with the line/column information of `other`.
+ #[cfg(procmacro2_semver_exempt)]
pub fn located_at(&self, other: Span) -> Span {
- Span(self.0.located_at(other.0))
+ Span::_new(self.inner.located_at(other.inner))
}
/// This method is only available when the `"nightly"` feature is enabled.
- #[cfg(feature = "nightly")]
+ #[cfg(all(feature = "nightly", feature = "proc-macro"))]
pub fn unstable(self) -> proc_macro::Span {
- self.0.unstable()
+ self.inner.unstable()
}
#[cfg(procmacro2_semver_exempt)]
pub fn source_file(&self) -> SourceFile {
- SourceFile(self.0.source_file())
+ SourceFile(self.inner.source_file())
}
#[cfg(procmacro2_semver_exempt)]
pub fn start(&self) -> LineColumn {
- let imp::LineColumn{ line, column } = self.0.start();
- LineColumn { line: line, column: column }
+ let imp::LineColumn { line, column } = self.inner.start();
+ LineColumn {
+ line: line,
+ column: column,
+ }
}
#[cfg(procmacro2_semver_exempt)]
pub fn end(&self) -> LineColumn {
- let imp::LineColumn{ line, column } = self.0.end();
- LineColumn { line: line, column: column }
+ let imp::LineColumn { line, column } = self.inner.end();
+ LineColumn {
+ line: line,
+ column: column,
+ }
}
#[cfg(procmacro2_semver_exempt)]
pub fn join(&self, other: Span) -> Option<Span> {
- self.0.join(other.0).map(Span)
+ self.inner.join(other.inner).map(Span::_new)
+ }
+
+ #[cfg(procmacro2_semver_exempt)]
+ pub fn eq(&self, other: &Span) -> bool {
+ self.inner.eq(&other.inner)
+ }
+}
+
+impl fmt::Debug for Span {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
}
}
#[derive(Clone, Debug)]
-pub struct TokenTree {
- pub span: Span,
- pub kind: TokenNode,
+pub enum TokenTree {
+ Group(Group),
+ Term(Term),
+ Op(Op),
+ Literal(Literal),
}
-impl From<TokenNode> for TokenTree {
- fn from(kind: TokenNode) -> TokenTree {
- TokenTree { span: Span::def_site(), kind: kind }
+impl TokenTree {
+ pub fn span(&self) -> Span {
+ match *self {
+ TokenTree::Group(ref t) => t.span(),
+ TokenTree::Term(ref t) => t.span(),
+ TokenTree::Op(ref t) => t.span(),
+ TokenTree::Literal(ref t) => t.span(),
+ }
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ match *self {
+ TokenTree::Group(ref mut t) => t.set_span(span),
+ TokenTree::Term(ref mut t) => t.set_span(span),
+ TokenTree::Op(ref mut t) => t.set_span(span),
+ TokenTree::Literal(ref mut t) => t.set_span(span),
+ }
+ }
+}
+
+impl From<Group> for TokenTree {
+ fn from(g: Group) -> TokenTree {
+ TokenTree::Group(g)
+ }
+}
+
+impl From<Term> for TokenTree {
+ fn from(g: Term) -> TokenTree {
+ TokenTree::Term(g)
+ }
+}
+
+impl From<Op> for TokenTree {
+ fn from(g: Op) -> TokenTree {
+ TokenTree::Op(g)
+ }
+}
+
+impl From<Literal> for TokenTree {
+ fn from(g: Literal) -> TokenTree {
+ TokenTree::Literal(g)
}
}
impl fmt::Display for TokenTree {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- TokenStream::from(self.clone()).fmt(f)
+ match *self {
+ TokenTree::Group(ref t) => t.fmt(f),
+ TokenTree::Term(ref t) => t.fmt(f),
+ TokenTree::Op(ref t) => t.fmt(f),
+ TokenTree::Literal(ref t) => t.fmt(f),
+ }
}
}
#[derive(Clone, Debug)]
-pub enum TokenNode {
- Group(Delimiter, TokenStream),
- Term(Term),
- Op(char, Spacing),
- Literal(Literal),
+pub struct Group {
+ delimiter: Delimiter,
+ stream: TokenStream,
+ span: Span,
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Delimiter {
Parenthesis,
Brace,
Bracket,
None,
}
-#[derive(Copy, Clone)]
-pub struct Term(imp::Term);
+impl Group {
+ pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
+ Group {
+ delimiter: delimiter,
+ stream: stream,
+ span: Span::call_site(),
+ }
+ }
-impl Term {
- pub fn intern(string: &str) -> Term {
- Term(imp::Term::intern(string))
+ pub fn delimiter(&self) -> Delimiter {
+ self.delimiter
+ }
+
+ pub fn stream(&self) -> TokenStream {
+ self.stream.clone()
}
- pub fn as_str(&self) -> &str {
- self.0.as_str()
+ pub fn span(&self) -> Span {
+ self.span
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
}
}
+impl fmt::Display for Group {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.stream.fmt(f)
+ }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct Op {
+ op: char,
+ spacing: Spacing,
+ span: Span,
+}
+
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Spacing {
Alone,
Joint,
}
+impl Op {
+ pub fn new(op: char, spacing: Spacing) -> Op {
+ Op {
+ op: op,
+ spacing: spacing,
+ span: Span::call_site(),
+ }
+ }
+
+ pub fn op(&self) -> char {
+ self.op
+ }
+
+ pub fn spacing(&self) -> Spacing {
+ self.spacing
+ }
+
+ pub fn span(&self) -> Span {
+ self.span
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
+ }
+}
+
+impl fmt::Display for Op {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.op.fmt(f)
+ }
+}
+
+#[derive(Copy, Clone)]
+pub struct Term {
+ inner: imp::Term,
+ _marker: marker::PhantomData<Rc<()>>,
+}
+
+impl Term {
+ fn _new(inner: imp::Term) -> Term {
+ Term {
+ inner: inner,
+ _marker: marker::PhantomData,
+ }
+ }
+
+ pub fn new(string: &str, span: Span) -> Term {
+ Term::_new(imp::Term::new(string, span.inner))
+ }
+
+ pub fn as_str(&self) -> &str {
+ self.inner.as_str()
+ }
+
+ pub fn span(&self) -> Span {
+ Span::_new(self.inner.span())
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.inner.set_span(span.inner);
+ }
+}
+
+impl fmt::Display for Term {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.as_str().fmt(f)
+ }
+}
+
+impl fmt::Debug for Term {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
+ }
+}
+
#[derive(Clone)]
-pub struct Literal(imp::Literal);
+pub struct Literal {
+ inner: imp::Literal,
+ _marker: marker::PhantomData<Rc<()>>,
+}
macro_rules! int_literals {
- ($($kind:ident,)*) => ($(
- pub fn $kind(n: $kind) -> Literal {
- Literal(n.into())
+ ($($name:ident => $kind:ident,)*) => ($(
+ pub fn $name(n: $kind) -> Literal {
+ Literal::_new(imp::Literal::$name(n))
}
)*)
}
impl Literal {
- pub fn integer(s: i64) -> Literal {
- Literal(imp::Literal::integer(s))
+ fn _new(inner: imp::Literal) -> Literal {
+ Literal {
+ inner: inner,
+ _marker: marker::PhantomData,
+ }
}
int_literals! {
- u8, u16, u32, u64, usize,
- i8, i16, i32, i64, isize,
+ u8_suffixed => u8,
+ u16_suffixed => u16,
+ u32_suffixed => u32,
+ u64_suffixed => u64,
+ usize_suffixed => usize,
+ i8_suffixed => i8,
+ i16_suffixed => i16,
+ i32_suffixed => i32,
+ i64_suffixed => i64,
+ isize_suffixed => isize,
+
+ u8_unsuffixed => u8,
+ u16_unsuffixed => u16,
+ u32_unsuffixed => u32,
+ u64_unsuffixed => u64,
+ usize_unsuffixed => usize,
+ i8_unsuffixed => i8,
+ i16_unsuffixed => i16,
+ i32_unsuffixed => i32,
+ i64_unsuffixed => i64,
+ isize_unsuffixed => isize,
}
- pub fn float(f: f64) -> Literal {
- Literal(imp::Literal::float(f))
+ pub fn f64_unsuffixed(f: f64) -> Literal {
+ assert!(f.is_finite());
+ Literal::_new(imp::Literal::f64_unsuffixed(f))
}
- pub fn f64(f: f64) -> Literal {
- Literal(f.into())
+ pub fn f64_suffixed(f: f64) -> Literal {
+ assert!(f.is_finite());
+ Literal::_new(imp::Literal::f64_suffixed(f))
}
- pub fn f32(f: f32) -> Literal {
- Literal(f.into())
+ pub fn f32_unsuffixed(f: f32) -> Literal {
+ assert!(f.is_finite());
+ Literal::_new(imp::Literal::f32_unsuffixed(f))
+ }
+
+ pub fn f32_suffixed(f: f32) -> Literal {
+ assert!(f.is_finite());
+ Literal::_new(imp::Literal::f32_suffixed(f))
}
pub fn string(string: &str) -> Literal {
- Literal(string.into())
+ Literal::_new(imp::Literal::string(string))
}
pub fn character(ch: char) -> Literal {
- Literal(ch.into())
+ Literal::_new(imp::Literal::character(ch))
}
pub fn byte_string(s: &[u8]) -> Literal {
- Literal(imp::Literal::byte_string(s))
+ Literal::_new(imp::Literal::byte_string(s))
}
- // =======================================================================
- // Not present upstream in proc_macro yet
-
- pub fn byte_char(b: u8) -> Literal {
- Literal(imp::Literal::byte_char(b))
+ pub fn span(&self) -> Span {
+ Span::_new(self.inner.span())
}
- pub fn doccomment(s: &str) -> Literal {
- Literal(imp::Literal::doccomment(s))
+ pub fn set_span(&mut self, span: Span) {
+ self.inner.set_span(span.inner);
}
+}
- pub fn raw_string(s: &str, pounds: usize) -> Literal {
- Literal(imp::Literal::raw_string(s, pounds))
+impl fmt::Debug for Literal {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
}
+}
- pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
- Literal(imp::Literal::raw_byte_string(s, pounds))
+impl fmt::Display for Literal {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
}
}
-pub struct TokenTreeIter(imp::TokenTreeIter);
+pub mod token_stream {
+ use std::fmt;
+ use std::marker;
+ use std::rc::Rc;
+
+ pub use TokenStream;
+ use TokenTree;
+ use imp;
+
+ pub struct IntoIter {
+ inner: imp::TokenTreeIter,
+ _marker: marker::PhantomData<Rc<()>>,
+ }
+
+ impl Iterator for IntoIter {
+ type Item = TokenTree;
-impl Iterator for TokenTreeIter {
- type Item = TokenTree;
+ fn next(&mut self) -> Option<TokenTree> {
+ self.inner.next()
+ }
+ }
+
+ impl fmt::Debug for IntoIter {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
+ }
+ }
- fn next(&mut self) -> Option<TokenTree> {
- self.0.next()
+ impl IntoIterator for TokenStream {
+ type Item = TokenTree;
+ type IntoIter = IntoIter;
+
+ fn into_iter(self) -> IntoIter {
+ IntoIter {
+ inner: self.inner.into_iter(),
+ _marker: marker::PhantomData,
+ }
+ }
}
}
-
-forward_fmt!(Debug for LexError);
-forward_fmt!(Debug for Literal);
-forward_fmt!(Debug for Span);
-forward_fmt!(Debug for Term);
-forward_fmt!(Debug for TokenTreeIter);
-forward_fmt!(Debug for TokenStream);
-forward_fmt!(Display for Literal);
-forward_fmt!(Display for TokenStream);
--- a/third_party/rust/proc-macro2/src/stable.rs
+++ b/third_party/rust/proc-macro2/src/stable.rs
@@ -1,26 +1,25 @@
-use std::ascii;
+#![cfg_attr(not(procmacro2_semver_exempt), allow(dead_code))]
+
use std::borrow::Borrow;
use std::cell::RefCell;
#[cfg(procmacro2_semver_exempt)]
use std::cmp;
use std::collections::HashMap;
use std::fmt;
use std::iter;
-use std::marker::PhantomData;
use std::rc::Rc;
use std::str::FromStr;
use std::vec;
-use proc_macro;
+use strnom::{block_comment, skip_whitespace, whitespace, word_break, Cursor, PResult};
use unicode_xid::UnicodeXID;
-use strnom::{Cursor, PResult, skip_whitespace, block_comment, whitespace, word_break};
-use {TokenTree, TokenNode, Delimiter, Spacing};
+use {Delimiter, Group, Op, Spacing, TokenTree};
#[derive(Clone, Debug)]
pub struct TokenStream {
inner: Vec<TokenTree>,
}
#[derive(Debug)]
pub struct LexError;
@@ -46,110 +45,109 @@ fn get_cursor(src: &str) -> Cursor {
rest: src,
off: span.lo,
}
})
}
#[cfg(not(procmacro2_semver_exempt))]
fn get_cursor(src: &str) -> Cursor {
- Cursor {
- rest: src,
- }
+ Cursor { rest: src }
}
impl FromStr for TokenStream {
type Err = LexError;
fn from_str(src: &str) -> Result<TokenStream, LexError> {
// Create a dummy file & add it to the codemap
let cursor = get_cursor(src);
match token_stream(cursor) {
Ok((input, output)) => {
if skip_whitespace(input).len() != 0 {
Err(LexError)
} else {
- Ok(output.0)
+ Ok(output.inner)
}
}
Err(LexError) => Err(LexError),
}
}
}
impl fmt::Display for TokenStream {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut joint = false;
for (i, tt) in self.inner.iter().enumerate() {
if i != 0 && !joint {
write!(f, " ")?;
}
joint = false;
- match tt.kind {
- TokenNode::Group(delim, ref stream) => {
- let (start, end) = match delim {
+ match *tt {
+ TokenTree::Group(ref tt) => {
+ let (start, end) = match tt.delimiter() {
Delimiter::Parenthesis => ("(", ")"),
Delimiter::Brace => ("{", "}"),
Delimiter::Bracket => ("[", "]"),
Delimiter::None => ("", ""),
};
- if stream.0.inner.len() == 0 {
+ if tt.stream().inner.inner.len() == 0 {
write!(f, "{} {}", start, end)?
} else {
- write!(f, "{} {} {}", start, stream, end)?
+ write!(f, "{} {} {}", start, tt.stream(), end)?
}
}
- TokenNode::Term(ref sym) => write!(f, "{}", sym.as_str())?,
- TokenNode::Op(ch, ref op) => {
- write!(f, "{}", ch)?;
- match *op {
+ TokenTree::Term(ref tt) => write!(f, "{}", tt.as_str())?,
+ TokenTree::Op(ref tt) => {
+ write!(f, "{}", tt.op())?;
+ match tt.spacing() {
Spacing::Alone => {}
Spacing::Joint => joint = true,
}
}
- TokenNode::Literal(ref literal) => {
- write!(f, "{}", literal)?;
- // handle comments
- if (literal.0).0.starts_with("/") {
- write!(f, "\n")?;
- }
- }
+ TokenTree::Literal(ref tt) => write!(f, "{}", tt)?,
}
}
Ok(())
}
}
-impl From<proc_macro::TokenStream> for TokenStream {
- fn from(inner: proc_macro::TokenStream) -> TokenStream {
- inner.to_string().parse().expect("compiler token stream parse failed")
+#[cfg(feature = "proc-macro")]
+impl From<::proc_macro::TokenStream> for TokenStream {
+ fn from(inner: ::proc_macro::TokenStream) -> TokenStream {
+ inner
+ .to_string()
+ .parse()
+ .expect("compiler token stream parse failed")
}
}
-impl From<TokenStream> for proc_macro::TokenStream {
- fn from(inner: TokenStream) -> proc_macro::TokenStream {
- inner.to_string().parse().expect("failed to parse to compiler tokens")
+#[cfg(feature = "proc-macro")]
+impl From<TokenStream> for ::proc_macro::TokenStream {
+ fn from(inner: TokenStream) -> ::proc_macro::TokenStream {
+ inner
+ .to_string()
+ .parse()
+ .expect("failed to parse to compiler tokens")
}
}
-
impl From<TokenTree> for TokenStream {
fn from(tree: TokenTree) -> TokenStream {
TokenStream { inner: vec![tree] }
}
}
-impl iter::FromIterator<TokenStream> for TokenStream {
- fn from_iter<I: IntoIterator<Item=TokenStream>>(streams: I) -> Self {
+impl iter::FromIterator<TokenTree> for TokenStream {
+ fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
let mut v = Vec::new();
- for stream in streams.into_iter() {
- v.extend(stream.inner);
+ for token in streams.into_iter() {
+ v.push(token);
}
TokenStream { inner: v }
}
}
pub type TokenTreeIter = vec::IntoIter<TokenTree>;
@@ -234,36 +232,39 @@ struct FileInfo {
name: String,
span: Span,
lines: Vec<usize>,
}
#[cfg(procmacro2_semver_exempt)]
impl FileInfo {
fn offset_line_column(&self, offset: usize) -> LineColumn {
- assert!(self.span_within(Span { lo: offset as u32, hi: offset as u32 }));
+ assert!(self.span_within(Span {
+ lo: offset as u32,
+ hi: offset as u32
+ }));
let offset = offset - self.span.lo as usize;
match self.lines.binary_search(&offset) {
Ok(found) => LineColumn {
line: found + 1,
- column: 0
+ column: 0,
},
Err(idx) => LineColumn {
line: idx,
- column: offset - self.lines[idx - 1]
+ column: offset - self.lines[idx - 1],
},
}
}
fn span_within(&self, span: Span) -> bool {
span.lo >= self.span.lo && span.hi <= self.span.hi
}
}
-/// Computes the offsets of each line in the given source string.
+/// Computesthe offsets of each line in the given source string.
#[cfg(procmacro2_semver_exempt)]
fn lines_offsets(s: &str) -> Vec<usize> {
let mut lines = vec![0];
let mut prev = 0;
while let Some(len) = s[prev..].find('\n') {
prev += len + 1;
lines.push(prev);
}
@@ -284,17 +285,20 @@ impl Codemap {
// with a dummy file.
self.files.last().unwrap().span.hi + 1
}
fn add_file(&mut self, name: &str, src: &str) -> Span {
let lines = lines_offsets(src);
let lo = self.next_start_pos();
// XXX(nika): Shouild we bother doing a checked cast or checked add here?
- let span = Span { lo: lo, hi: lo + (src.len() as u32) };
+ let span = Span {
+ lo: lo,
+ hi: lo + (src.len() as u32),
+ };
self.files.push(FileInfo {
name: name.to_owned(),
span: span,
lines: lines,
});
span
@@ -305,17 +309,17 @@ impl Codemap {
if file.span_within(span) {
return file;
}
}
panic!("Invalid span with no related FileInfo!");
}
}
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Span {
#[cfg(procmacro2_semver_exempt)]
lo: u32,
#[cfg(procmacro2_semver_exempt)]
hi: u32,
}
impl Span {
@@ -387,37 +391,81 @@ impl Span {
})
})
}
}
#[derive(Copy, Clone)]
pub struct Term {
intern: usize,
- not_send_sync: PhantomData<*const ()>,
+ span: Span,
}
thread_local!(static SYMBOLS: RefCell<Interner> = RefCell::new(Interner::new()));
impl Term {
- pub fn intern(string: &str) -> Term {
+ pub fn new(string: &str, span: Span) -> Term {
+ validate_term(string);
+
Term {
intern: SYMBOLS.with(|s| s.borrow_mut().intern(string)),
- not_send_sync: PhantomData,
+ span: span,
}
}
pub fn as_str(&self) -> &str {
SYMBOLS.with(|interner| {
let interner = interner.borrow();
let s = interner.get(self.intern);
- unsafe {
- &*(s as *const str)
+ unsafe { &*(s as *const str) }
+ })
+ }
+
+ pub fn span(&self) -> Span {
+ self.span
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
+ }
+}
+
+fn validate_term(string: &str) {
+ let validate = if string.starts_with('\'') {
+ &string[1..]
+ } else if string.starts_with("r#") {
+ &string[2..]
+ } else {
+ string
+ };
+
+ if validate.is_empty() {
+ panic!("Term is not allowed to be empty; use Option<Term>");
+ }
+
+ if validate.bytes().all(|digit| digit >= b'0' && digit <= b'9') {
+ panic!("Term cannot be a number; use Literal instead");
+ }
+
+ fn xid_ok(string: &str) -> bool {
+ let mut chars = string.chars();
+ let first = chars.next().unwrap();
+ if !(UnicodeXID::is_xid_start(first) || first == '_') {
+ return false;
+ }
+ for ch in chars {
+ if !UnicodeXID::is_xid_continue(ch) {
+ return false;
}
- })
+ }
+ true
+ }
+
+ if !xid_ok(validate) {
+ panic!("{:?} is not a valid Term", string);
}
}
impl fmt::Debug for Term {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Term").field(&self.as_str()).finish()
}
}
@@ -439,272 +487,297 @@ impl Borrow<str> for MyRc {
impl Interner {
fn new() -> Interner {
Interner {
string_to_index: HashMap::new(),
index_to_string: Vec::new(),
}
}
- fn intern(&mut self, s: &str) -> usize {
+ fn intern(&mut self, s: &str) -> usize {
if let Some(&idx) = self.string_to_index.get(s) {
- return idx
+ return idx;
}
let s = Rc::new(s.to_string());
self.index_to_string.push(s.clone());
- self.string_to_index.insert(MyRc(s), self.index_to_string.len() - 1);
+ self.string_to_index
+ .insert(MyRc(s), self.index_to_string.len() - 1);
self.index_to_string.len() - 1
}
- fn get(&self, idx: usize) -> &str {
- &self.index_to_string[idx]
- }
+ fn get(&self, idx: usize) -> &str {
+ &self.index_to_string[idx]
+ }
}
#[derive(Clone, Debug)]
-pub struct Literal(String);
+pub struct Literal {
+ text: String,
+ span: Span,
+}
+
+macro_rules! suffixed_numbers {
+ ($($name:ident => $kind:ident,)*) => ($(
+ pub fn $name(n: $kind) -> Literal {
+ Literal::_new(format!(concat!("{}", stringify!($kind)), n))
+ }
+ )*)
+}
+
+macro_rules! unsuffixed_numbers {
+ ($($name:ident => $kind:ident,)*) => ($(
+ pub fn $name(n: $kind) -> Literal {
+ Literal::_new(n.to_string())
+ }
+ )*)
+}
impl Literal {
- pub fn byte_char(byte: u8) -> Literal {
- match byte {
- 0 => Literal(format!("b'\\0'")),
- b'\"' => Literal(format!("b'\"'")),
- n => {
- let mut escaped = "b'".to_string();
- escaped.extend(ascii::escape_default(n).map(|c| c as char));
- escaped.push('\'');
- Literal(escaped)
- }
+ fn _new(text: String) -> Literal {
+ Literal {
+ text: text,
+ span: Span::call_site(),
}
}
+ suffixed_numbers! {
+ u8_suffixed => u8,
+ u16_suffixed => u16,
+ u32_suffixed => u32,
+ u64_suffixed => u64,
+ usize_suffixed => usize,
+ i8_suffixed => i8,
+ i16_suffixed => i16,
+ i32_suffixed => i32,
+ i64_suffixed => i64,
+ isize_suffixed => isize,
+
+ f32_suffixed => f32,
+ f64_suffixed => f64,
+ }
+
+ unsuffixed_numbers! {
+ u8_unsuffixed => u8,
+ u16_unsuffixed => u16,
+ u32_unsuffixed => u32,
+ u64_unsuffixed => u64,
+ usize_unsuffixed => usize,
+ i8_unsuffixed => i8,
+ i16_unsuffixed => i16,
+ i32_unsuffixed => i32,
+ i64_unsuffixed => i64,
+ isize_unsuffixed => isize,
+ }
+
+ pub fn f32_unsuffixed(f: f32) -> Literal {
+ let mut s = f.to_string();
+ if !s.contains(".") {
+ s.push_str(".0");
+ }
+ Literal::_new(s)
+ }
+
+ pub fn f64_unsuffixed(f: f64) -> Literal {
+ let mut s = f.to_string();
+ if !s.contains(".") {
+ s.push_str(".0");
+ }
+ Literal::_new(s)
+ }
+
+ pub fn string(t: &str) -> Literal {
+ let mut s = t.chars()
+ .flat_map(|c| c.escape_default())
+ .collect::<String>();
+ s.push('"');
+ s.insert(0, '"');
+ Literal::_new(s)
+ }
+
+ pub fn character(t: char) -> Literal {
+ Literal::_new(format!("'{}'", t.escape_default().collect::<String>()))
+ }
+
pub fn byte_string(bytes: &[u8]) -> Literal {
let mut escaped = "b\"".to_string();
for b in bytes {
match *b {
b'\0' => escaped.push_str(r"\0"),
b'\t' => escaped.push_str(r"\t"),
b'\n' => escaped.push_str(r"\n"),
b'\r' => escaped.push_str(r"\r"),
b'"' => escaped.push_str("\\\""),
b'\\' => escaped.push_str("\\\\"),
- b'\x20' ... b'\x7E' => escaped.push(*b as char),
+ b'\x20'...b'\x7E' => escaped.push(*b as char),
_ => escaped.push_str(&format!("\\x{:02X}", b)),
}
}
escaped.push('"');
- Literal(escaped)
- }
-
- pub fn doccomment(s: &str) -> Literal {
- Literal(s.to_string())
- }
-
- pub fn float(n: f64) -> Literal {
- if !n.is_finite() {
- panic!("Invalid float literal {}", n);
- }
- let mut s = n.to_string();
- if !s.contains('.') {
- s += ".0";
- }
- Literal(s)
+ Literal::_new(escaped)
}
- pub fn integer(s: i64) -> Literal {
- Literal(s.to_string())
+ pub fn span(&self) -> Span {
+ self.span
}
- pub fn raw_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("r");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(ret)
- }
-
- pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("br");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(ret)
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
}
}
impl fmt::Display for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
- }
-}
-
-macro_rules! ints {
- ($($t:ty,)*) => {$(
- impl From<$t> for Literal {
- fn from(t: $t) -> Literal {
- Literal(format!(concat!("{}", stringify!($t)), t))
- }
- }
- )*}
-}
-
-ints! {
- u8, u16, u32, u64, usize,
- i8, i16, i32, i64, isize,
-}
-
-macro_rules! floats {
- ($($t:ty,)*) => {$(
- impl From<$t> for Literal {
- fn from(t: $t) -> Literal {
- assert!(!t.is_nan());
- assert!(!t.is_infinite());
- Literal(format!(concat!("{}", stringify!($t)), t))
- }
- }
- )*}
-}
-
-floats! {
- f32, f64,
-}
-
-impl<'a> From<&'a str> for Literal {
- fn from(t: &'a str) -> Literal {
- let mut s = t.chars().flat_map(|c| c.escape_default()).collect::<String>();
- s.push('"');
- s.insert(0, '"');
- Literal(s)
+ self.text.fmt(f)
}
}
-impl From<char> for Literal {
- fn from(t: char) -> Literal {
- Literal(format!("'{}'", t.escape_default().collect::<String>()))
+fn token_stream(mut input: Cursor) -> PResult<::TokenStream> {
+ let mut trees = Vec::new();
+ loop {
+ let input_no_ws = skip_whitespace(input);
+ if input_no_ws.rest.len() == 0 {
+ break
+ }
+ if let Ok((a, tokens)) = doc_comment(input_no_ws) {
+ input = a;
+ trees.extend(tokens);
+ continue
+ }
+
+ let (a, tt) = match token_tree(input_no_ws) {
+ Ok(p) => p,
+ Err(_) => break,
+ };
+ trees.push(tt);
+ input = a;
}
+ Ok((input, ::TokenStream::_new(TokenStream { inner: trees })))
}
-named!(token_stream -> ::TokenStream, map!(
- many0!(token_tree),
- |trees| ::TokenStream(TokenStream { inner: trees })
-));
-
#[cfg(not(procmacro2_semver_exempt))]
-fn token_tree(input: Cursor) -> PResult<TokenTree> {
- let (input, kind) = token_kind(input)?;
- Ok((input, TokenTree {
- span: ::Span(Span {}),
- kind: kind,
- }))
+fn spanned<'a, T>(
+ input: Cursor<'a>,
+ f: fn(Cursor<'a>) -> PResult<'a, T>,
+) -> PResult<'a, (T, ::Span)> {
+ let (a, b) = f(skip_whitespace(input))?;
+ Ok((a, ((b, ::Span::_new(Span { })))))
}
#[cfg(procmacro2_semver_exempt)]
-fn token_tree(input: Cursor) -> PResult<TokenTree> {
+fn spanned<'a, T>(
+ input: Cursor<'a>,
+ f: fn(Cursor<'a>) -> PResult<'a, T>,
+) -> PResult<'a, (T, ::Span)> {
let input = skip_whitespace(input);
let lo = input.off;
- let (input, kind) = token_kind(input)?;
- let hi = input.off;
- Ok((input, TokenTree {
- span: ::Span(Span {
- lo: lo,
- hi: hi,
- }),
- kind: kind,
- }))
+ let (a, b) = f(input)?;
+ let hi = a.off;
+ let span = ::Span::_new(Span { lo: lo, hi: hi });
+ Ok((a, (b, span)))
}
-named!(token_kind -> TokenNode, alt!(
- map!(delimited, |(d, s)| TokenNode::Group(d, s))
+fn token_tree(input: Cursor) -> PResult<TokenTree> {
+ let (rest, (mut tt, span)) = spanned(input, token_kind)?;
+ tt.set_span(span);
+ Ok((rest, tt))
+}
+
+named!(token_kind -> TokenTree, alt!(
+ map!(group, TokenTree::Group)
|
- map!(literal, TokenNode::Literal) // must be before symbol
+ map!(literal, TokenTree::Literal) // must be before symbol
|
symbol
|
- map!(op, |(op, kind)| TokenNode::Op(op, kind))
+ map!(op, TokenTree::Op)
));
-named!(delimited -> (Delimiter, ::TokenStream), alt!(
+named!(group -> Group, alt!(
delimited!(
punct!("("),
token_stream,
punct!(")")
- ) => { |ts| (Delimiter::Parenthesis, ts) }
+ ) => { |ts| Group::new(Delimiter::Parenthesis, ts) }
|
delimited!(
punct!("["),
token_stream,
punct!("]")
- ) => { |ts| (Delimiter::Bracket, ts) }
+ ) => { |ts| Group::new(Delimiter::Bracket, ts) }
|
delimited!(
punct!("{"),
token_stream,
punct!("}")
- ) => { |ts| (Delimiter::Brace, ts) }
+ ) => { |ts| Group::new(Delimiter::Brace, ts) }
));
-fn symbol(mut input: Cursor) -> PResult<TokenNode> {
+fn symbol(mut input: Cursor) -> PResult<TokenTree> {
input = skip_whitespace(input);
let mut chars = input.char_indices();
let lifetime = input.starts_with("'");
if lifetime {
chars.next();
}
+ let raw = !lifetime && input.starts_with("r#");
+ if raw {
+ chars.next();
+ chars.next();
+ }
+
match chars.next() {
Some((_, ch)) if UnicodeXID::is_xid_start(ch) || ch == '_' => {}
_ => return Err(LexError),
}
let mut end = input.len();
for (i, ch) in chars {
if !UnicodeXID::is_xid_continue(ch) {
end = i;
break;
}
}
- if lifetime && &input.rest[..end] != "'static" && KEYWORDS.contains(&&input.rest[1..end]) {
+ let a = &input.rest[..end];
+ if a == "r#_" || lifetime && a != "'static" && KEYWORDS.contains(&&a[1..]) {
Err(LexError)
+ } else if a == "_" {
+ Ok((input.advance(end), Op::new('_', Spacing::Alone).into()))
} else {
- let a = &input.rest[..end];
- if a == "_" {
- Ok((input.advance(end), TokenNode::Op('_', Spacing::Alone)))
- } else {
- Ok((input.advance(end), TokenNode::Term(::Term::intern(a))))
- }
+ Ok((
+ input.advance(end),
+ ::Term::new(a, ::Span::call_site()).into(),
+ ))
}
}
// From https://github.com/rust-lang/rust/blob/master/src/libsyntax_pos/symbol.rs
static KEYWORDS: &'static [&'static str] = &[
- "abstract", "alignof", "as", "become", "box", "break", "const", "continue",
- "crate", "do", "else", "enum", "extern", "false", "final", "fn", "for",
- "if", "impl", "in", "let", "loop", "macro", "match", "mod", "move", "mut",
- "offsetof", "override", "priv", "proc", "pub", "pure", "ref", "return",
- "self", "Self", "sizeof", "static", "struct", "super", "trait", "true",
- "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while",
- "yield",
+ "abstract", "alignof", "as", "become", "box", "break", "const", "continue", "crate", "do",
+ "else", "enum", "extern", "false", "final", "fn", "for", "if", "impl", "in", "let", "loop",
+ "macro", "match", "mod", "move", "mut", "offsetof", "override", "priv", "proc", "pub", "pure",
+ "ref", "return", "self", "Self", "sizeof", "static", "struct", "super", "trait", "true",
+ "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while", "yield",
];
fn literal(input: Cursor) -> PResult<::Literal> {
let input_no_ws = skip_whitespace(input);
match literal_nocapture(input_no_ws) {
Ok((a, ())) => {
let start = input.len() - input_no_ws.len();
let len = input_no_ws.len() - a.len();
let end = start + len;
- Ok((a, ::Literal(Literal(input.rest[start..end].to_string()))))
+ Ok((
+ a,
+ ::Literal::_new(Literal::_new(input.rest[start..end].to_string())),
+ ))
}
Err(LexError) => Err(LexError),
}
}
named!(literal_nocapture -> (), alt!(
string
|
@@ -712,18 +785,16 @@ named!(literal_nocapture -> (), alt!(
|
byte
|
character
|
float
|
int
- |
- doc_comment
));
named!(string -> (), alt!(
quoted_string
|
preceded!(
punct!("r"),
raw_string
@@ -745,47 +816,40 @@ fn cooked_string(input: Cursor) -> PResu
}
'\r' => {
if let Some((_, '\n')) = chars.next() {
// ...
} else {
break;
}
}
- '\\' => {
- match chars.next() {
- Some((_, 'x')) => {
- if !backslash_x_char(&mut chars) {
- break
+ '\\' => match chars.next() {
+ Some((_, 'x')) => {
+ if !backslash_x_char(&mut chars) {
+ break;
+ }
+ }
+ Some((_, 'n')) | Some((_, 'r')) | Some((_, 't')) | Some((_, '\\'))
+ | Some((_, '\'')) | Some((_, '"')) | Some((_, '0')) => {}
+ Some((_, 'u')) => {
+ if !backslash_u(&mut chars) {
+ break;
+ }
+ }
+ Some((_, '\n')) | Some((_, '\r')) => {
+ while let Some(&(_, ch)) = chars.peek() {
+ if ch.is_whitespace() {
+ chars.next();
+ } else {
+ break;
}
}
- Some((_, 'n')) |
- Some((_, 'r')) |
- Some((_, 't')) |
- Some((_, '\\')) |
- Some((_, '\'')) |
- Some((_, '"')) |
- Some((_, '0')) => {}
- Some((_, 'u')) => {
- if !backslash_u(&mut chars) {
- break
- }
- }
- Some((_, '\n')) | Some((_, '\r')) => {
- while let Some(&(_, ch)) = chars.peek() {
- if ch.is_whitespace() {
- chars.next();
- } else {
- break;
- }
- }
- }
- _ => break,
}
- }
+ _ => break,
+ },
_ch => {}
}
}
Err(LexError)
}
named!(byte_string -> (), alt!(
delimited!(
@@ -809,45 +873,37 @@ fn cooked_byte_string(mut input: Cursor)
}
b'\r' => {
if let Some((_, b'\n')) = bytes.next() {
// ...
} else {
break;
}
}
- b'\\' => {
- match bytes.next() {
- Some((_, b'x')) => {
- if !backslash_x_byte(&mut bytes) {
- break
+ b'\\' => match bytes.next() {
+ Some((_, b'x')) => {
+ if !backslash_x_byte(&mut bytes) {
+ break;
+ }
+ }
+ Some((_, b'n')) | Some((_, b'r')) | Some((_, b't')) | Some((_, b'\\'))
+ | Some((_, b'0')) | Some((_, b'\'')) | Some((_, b'"')) => {}
+ Some((newline, b'\n')) | Some((newline, b'\r')) => {
+ let rest = input.advance(newline + 1);
+ for (offset, ch) in rest.char_indices() {
+ if !ch.is_whitespace() {
+ input = rest.advance(offset);
+ bytes = input.bytes().enumerate();
+ continue 'outer;
}
}
- Some((_, b'n')) |
- Some((_, b'r')) |
- Some((_, b't')) |
- Some((_, b'\\')) |
- Some((_, b'0')) |
- Some((_, b'\'')) |
- Some((_, b'"')) => {}
- Some((newline, b'\n')) |
- Some((newline, b'\r')) => {
- let rest = input.advance(newline + 1);
- for (offset, ch) in rest.char_indices() {
- if !ch.is_whitespace() {
- input = rest.advance(offset);
- bytes = input.bytes().enumerate();
- continue 'outer;
- }
- }
- break;
- }
- _ => break,
+ break;
}
- }
+ _ => break,
+ },
b if b < 0x80 => {}
_ => break,
}
}
Err(LexError)
}
fn raw_string(input: Cursor) -> PResult<()> {
@@ -862,17 +918,17 @@ fn raw_string(input: Cursor) -> PResult<
'#' => {}
_ => return Err(LexError),
}
}
for (byte_offset, ch) in chars {
match ch {
'"' if input.advance(byte_offset + 1).starts_with(&input.rest[..n]) => {
let rest = input.advance(byte_offset + 1 + n);
- return Ok((rest, ()))
+ return Ok((rest, ()));
}
'\r' => {}
_ => {}
}
}
Err(LexError)
}
@@ -882,29 +938,22 @@ named!(byte -> (), do_parse!(
cooked_byte >>
tag!("'") >>
(())
));
fn cooked_byte(input: Cursor) -> PResult<()> {
let mut bytes = input.bytes().enumerate();
let ok = match bytes.next().map(|(_, b)| b) {
- Some(b'\\') => {
- match bytes.next().map(|(_, b)| b) {
- Some(b'x') => backslash_x_byte(&mut bytes),
- Some(b'n') |
- Some(b'r') |
- Some(b't') |
- Some(b'\\') |
- Some(b'0') |
- Some(b'\'') |
- Some(b'"') => true,
- _ => false,
- }
- }
+ Some(b'\\') => match bytes.next().map(|(_, b)| b) {
+ Some(b'x') => backslash_x_byte(&mut bytes),
+ Some(b'n') | Some(b'r') | Some(b't') | Some(b'\\') | Some(b'0') | Some(b'\'')
+ | Some(b'"') => true,
+ _ => false,
+ },
b => b.is_some(),
};
if ok {
match bytes.next() {
Some((offset, _)) => {
if input.chars().as_str().is_char_boundary(offset) {
Ok((input.advance(offset), ()))
} else {
@@ -923,30 +972,24 @@ named!(character -> (), do_parse!(
cooked_char >>
tag!("'") >>
(())
));
fn cooked_char(input: Cursor) -> PResult<()> {
let mut chars = input.char_indices();
let ok = match chars.next().map(|(_, ch)| ch) {
- Some('\\') => {
- match chars.next().map(|(_, ch)| ch) {
- Some('x') => backslash_x_char(&mut chars),
- Some('u') => backslash_u(&mut chars),
- Some('n') |
- Some('r') |
- Some('t') |
- Some('\\') |
- Some('0') |
- Some('\'') |
- Some('"') => true,
- _ => false,
+ Some('\\') => match chars.next().map(|(_, ch)| ch) {
+ Some('x') => backslash_x_char(&mut chars),
+ Some('u') => backslash_u(&mut chars),
+ Some('n') | Some('r') | Some('t') | Some('\\') | Some('0') | Some('\'') | Some('"') => {
+ true
}
- }
+ _ => false,
+ },
ch => ch.is_some(),
};
if ok {
match chars.next() {
Some((idx, _)) => Ok((input.advance(idx), ())),
None => Ok((input.advance(input.len()), ())),
}
} else {
@@ -962,33 +1005,36 @@ macro_rules! next_ch {
_ => return false,
},
None => return false
}
};
}
fn backslash_x_char<I>(chars: &mut I) -> bool
- where I: Iterator<Item = (usize, char)>
+where
+ I: Iterator<Item = (usize, char)>,
{
next_ch!(chars @ '0'...'7');
next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F');
true
}
fn backslash_x_byte<I>(chars: &mut I) -> bool
- where I: Iterator<Item = (usize, u8)>
+where
+ I: Iterator<Item = (usize, u8)>,
{
next_ch!(chars @ b'0'...b'9' | b'a'...b'f' | b'A'...b'F');
next_ch!(chars @ b'0'...b'9' | b'a'...b'f' | b'A'...b'F');
true
}
fn backslash_u<I>(chars: &mut I) -> bool
- where I: Iterator<Item = (usize, char)>
+where
+ I: Iterator<Item = (usize, char)>,
{
next_ch!(chars @ '{');
next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F');
loop {
let c = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '_' | '}');
if c == '}' {
return true;
}
@@ -1021,19 +1067,21 @@ fn float_digits(input: Cursor) -> PResul
chars.next();
len += 1;
}
'.' => {
if has_dot {
break;
}
chars.next();
- if chars.peek()
- .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
- .unwrap_or(false) {
+ if chars
+ .peek()
+ .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
+ .unwrap_or(false)
+ {
return Err(LexError);
}
len += 1;
has_dot = true;
}
'e' | 'E' => {
chars.next();
len += 1;
@@ -1078,28 +1126,17 @@ fn float_digits(input: Cursor) -> PResul
}
Ok((input.advance(len), ()))
}
fn int(input: Cursor) -> PResult<()> {
let (rest, ()) = digits(input)?;
for suffix in &[
- "isize",
- "i8",
- "i16",
- "i32",
- "i64",
- "i128",
- "usize",
- "u8",
- "u16",
- "u32",
- "u64",
- "u128",
+ "isize", "i8", "i16", "i32", "i64", "i128", "usize", "u8", "u16", "u32", "u64", "u128"
] {
if rest.starts_with(suffix) {
return word_break(rest.advance(suffix.len()));
}
}
word_break(rest)
}
@@ -1141,25 +1178,25 @@ fn digits(mut input: Cursor) -> PResult<
}
if empty {
Err(LexError)
} else {
Ok((input.advance(len), ()))
}
}
-fn op(input: Cursor) -> PResult<(char, Spacing)> {
+fn op(input: Cursor) -> PResult<Op> {
let input = skip_whitespace(input);
match op_char(input) {
Ok((rest, ch)) => {
let kind = match op_char(rest) {
Ok(_) => Spacing::Joint,
Err(LexError) => Spacing::Alone,
};
- Ok((rest, (ch, kind)))
+ Ok((rest, Op::new(ch, kind)))
}
Err(LexError) => Err(LexError),
}
}
fn op_char(input: Cursor) -> PResult<char> {
let mut chars = input.chars();
let first = match chars.next() {
@@ -1171,36 +1208,58 @@ fn op_char(input: Cursor) -> PResult<cha
let recognized = "~!@#$%^&*-=+|;:,<.>/?";
if recognized.contains(first) {
Ok((input.advance(first.len_utf8()), first))
} else {
Err(LexError)
}
}
-named!(doc_comment -> (), alt!(
+fn doc_comment(input: Cursor) -> PResult<Vec<TokenTree>> {
+ let mut trees = Vec::new();
+ let (rest, ((comment, inner), span)) = spanned(input, doc_comment_contents)?;
+ trees.push(TokenTree::Op(Op::new('#', Spacing::Alone)));
+ if inner {
+ trees.push(Op::new('!', Spacing::Alone).into());
+ }
+ let mut stream = vec![
+ TokenTree::Term(::Term::new("doc", span)),
+ TokenTree::Op(Op::new('=', Spacing::Alone)),
+ TokenTree::Literal(::Literal::string(comment)),
+ ];
+ for tt in stream.iter_mut() {
+ tt.set_span(span);
+ }
+ trees.push(Group::new(Delimiter::Bracket, stream.into_iter().collect()).into());
+ for tt in trees.iter_mut() {
+ tt.set_span(span);
+ }
+ Ok((rest, trees))
+}
+
+named!(doc_comment_contents -> (&str, bool), alt!(
do_parse!(
punct!("//!") >>
- take_until!("\n") >>
- (())
+ s: take_until_newline_or_eof!() >>
+ ((s, true))
)
|
do_parse!(
option!(whitespace) >>
peek!(tag!("/*!")) >>
- block_comment >>
- (())
+ s: block_comment >>
+ ((s, true))
)
|
do_parse!(
punct!("///") >>
not!(tag!("/")) >>
- take_until!("\n") >>
- (())
+ s: take_until_newline_or_eof!() >>
+ ((s, false))
)
|
do_parse!(
option!(whitespace) >>
peek!(tuple!(tag!("/**"), not!(tag!("*")))) >>
- block_comment >>
- (())
+ s: block_comment >>
+ ((s, false))
)
));
--- a/third_party/rust/proc-macro2/src/strnom.rs
+++ b/third_party/rust/proc-macro2/src/strnom.rs
@@ -1,11 +1,11 @@
//! Adapted from [`nom`](https://github.com/Geal/nom).
-use std::str::{Chars, CharIndices, Bytes};
+use std::str::{Bytes, CharIndices, Chars};
use unicode_xid::UnicodeXID;
use imp::LexError;
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cursor<'a> {
pub rest: &'a str,
@@ -68,28 +68,30 @@ pub fn whitespace(input: Cursor) -> PRes
return Err(LexError);
}
let bytes = input.as_bytes();
let mut i = 0;
while i < bytes.len() {
let s = input.advance(i);
if bytes[i] == b'/' {
- if s.starts_with("//") && (!s.starts_with("///") || s.starts_with("////")) &&
- !s.starts_with("//!") {
+ if s.starts_with("//") && (!s.starts_with("///") || s.starts_with("////"))
+ && !s.starts_with("//!")
+ {
if let Some(len) = s.find('\n') {
i += len + 1;
continue;
}
break;
} else if s.starts_with("/**/") {
i += 4;
- continue
- } else if s.starts_with("/*") && (!s.starts_with("/**") || s.starts_with("/***")) &&
- !s.starts_with("/*!") {
+ continue;
+ } else if s.starts_with("/*") && (!s.starts_with("/**") || s.starts_with("/***"))
+ && !s.starts_with("/*!")
+ {
let (_, com) = block_comment(s)?;
i += com.len();
continue;
}
}
match bytes[i] {
b' ' | 0x09...0x0d => {
i += 1;
@@ -99,21 +101,17 @@ pub fn whitespace(input: Cursor) -> PRes
_ => {
let ch = s.chars().next().unwrap();
if is_whitespace(ch) {
i += ch.len_utf8();
continue;
}
}
}
- return if i > 0 {
- Ok((s, ()))
- } else {
- Err(LexError)
- };
+ return if i > 0 { Ok((s, ())) } else { Err(LexError) };
}
Ok((input.advance(input.len()), ()))
}
pub fn block_comment(input: Cursor) -> PResult<&str> {
if !input.starts_with("/*") {
return Err(LexError);
}
@@ -258,44 +256,24 @@ macro_rules! option {
($i:expr, $f:expr) => {
match $f($i) {
Ok((i, o)) => Ok((i, Some(o))),
Err(LexError) => Ok(($i, None)),
}
};
}
-macro_rules! take_until {
- ($i:expr, $substr:expr) => {{
- if $substr.len() > $i.len() {
- Err(LexError)
+macro_rules! take_until_newline_or_eof {
+ ($i:expr,) => {{
+ if $i.len() == 0 {
+ Ok(($i, ""))
} else {
- let substr_vec: Vec<char> = $substr.chars().collect();
- let mut window: Vec<char> = vec![];
- let mut offset = $i.len();
- let mut parsed = false;
- for (o, c) in $i.char_indices() {
- window.push(c);
- if window.len() > substr_vec.len() {
- window.remove(0);
- }
- if window == substr_vec {
- parsed = true;
- window.pop();
- let window_len: usize = window.iter()
- .map(|x| x.len_utf8())
- .fold(0, |x, y| x + y);
- offset = o - window_len;
- break;
- }
- }
- if parsed {
- Ok(($i.advance(offset), &$i.rest[..offset]))
- } else {
- Err(LexError)
+ match $i.find('\n') {
+ Some(i) => Ok(($i.advance(i), &$i.rest[..i])),
+ None => Ok(($i.advance($i.len()), &$i.rest[..$i.len()])),
}
}
}};
}
macro_rules! tuple {
($i:expr, $($rest:tt)*) => {
tuple_parser!($i, (), $($rest)*)
@@ -406,42 +384,8 @@ macro_rules! map {
Ok((i, o)) => Ok((i, call!(o, $g)))
}
};
($i:expr, $f:expr, $g:expr) => {
map!($i, call!($f), $g)
};
}
-
-macro_rules! many0 {
- ($i:expr, $f:expr) => {{
- let ret;
- let mut res = ::std::vec::Vec::new();
- let mut input = $i;
-
- loop {
- if input.is_empty() {
- ret = Ok((input, res));
- break;
- }
-
- match $f(input) {
- Err(LexError) => {
- ret = Ok((input, res));
- break;
- }
- Ok((i, o)) => {
- // loop trip must always consume (otherwise infinite loops)
- if i.len() == input.len() {
- ret = Err(LexError);
- break;
- }
-
- res.push(o);
- input = i;
- }
- }
- }
-
- ret
- }};
-}
--- a/third_party/rust/proc-macro2/src/unstable.rs
+++ b/third_party/rust/proc-macro2/src/unstable.rs
@@ -1,16 +1,17 @@
-use std::ascii;
+#![cfg_attr(not(procmacro2_semver_exempt), allow(dead_code))]
+
use std::fmt;
use std::iter;
use std::str::FromStr;
use proc_macro;
-use {TokenTree, TokenNode, Delimiter, Spacing};
+use {Delimiter, Group, Op, Spacing, TokenTree};
#[derive(Clone)]
pub struct TokenStream(proc_macro::TokenStream);
pub struct LexError(proc_macro::LexError);
impl TokenStream {
pub fn empty() -> TokenStream {
@@ -44,185 +45,181 @@ impl From<proc_macro::TokenStream> for T
impl From<TokenStream> for proc_macro::TokenStream {
fn from(inner: TokenStream) -> proc_macro::TokenStream {
inner.0
}
}
impl From<TokenTree> for TokenStream {
- fn from(tree: TokenTree) -> TokenStream {
- TokenStream(proc_macro::TokenTree {
- span: (tree.span.0).0,
- kind: match tree.kind {
- TokenNode::Group(delim, s) => {
- let delim = match delim {
- Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
- Delimiter::Bracket => proc_macro::Delimiter::Bracket,
- Delimiter::Brace => proc_macro::Delimiter::Brace,
- Delimiter::None => proc_macro::Delimiter::None,
- };
- proc_macro::TokenNode::Group(delim, (s.0).0)
- }
- TokenNode::Op(ch, kind) => {
- let kind = match kind {
- Spacing::Joint => proc_macro::Spacing::Joint,
- Spacing::Alone => proc_macro::Spacing::Alone,
- };
- proc_macro::TokenNode::Op(ch, kind)
- }
- TokenNode::Term(s) => {
- proc_macro::TokenNode::Term((s.0).0)
- }
- TokenNode::Literal(l) => {
- proc_macro::TokenNode::Literal((l.0).0)
- }
- },
- }.into())
+ fn from(token: TokenTree) -> TokenStream {
+ let tt: proc_macro::TokenTree = match token {
+ TokenTree::Group(tt) => {
+ let delim = match tt.delimiter() {
+ Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
+ Delimiter::Bracket => proc_macro::Delimiter::Bracket,
+ Delimiter::Brace => proc_macro::Delimiter::Brace,
+ Delimiter::None => proc_macro::Delimiter::None,
+ };
+ let span = tt.span();
+ let mut group = proc_macro::Group::new(delim, tt.stream.inner.0);
+ group.set_span(span.inner.0);
+ group.into()
+ }
+ TokenTree::Op(tt) => {
+ let spacing = match tt.spacing() {
+ Spacing::Joint => proc_macro::Spacing::Joint,
+ Spacing::Alone => proc_macro::Spacing::Alone,
+ };
+ let mut op = proc_macro::Op::new(tt.op(), spacing);
+ op.set_span(tt.span().inner.0);
+ op.into()
+ }
+ TokenTree::Term(tt) => tt.inner.term.into(),
+ TokenTree::Literal(tt) => tt.inner.lit.into(),
+ };
+ TokenStream(tt.into())
}
}
-impl iter::FromIterator<TokenStream> for TokenStream {
- fn from_iter<I: IntoIterator<Item=TokenStream>>(streams: I) -> Self {
- let streams = streams.into_iter().map(|s| s.0);
+impl iter::FromIterator<TokenTree> for TokenStream {
+ fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
+ let streams = streams.into_iter().map(TokenStream::from)
+ .flat_map(|t| t.0);
TokenStream(streams.collect::<proc_macro::TokenStream>())
}
}
impl fmt::Debug for TokenStream {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
impl fmt::Debug for LexError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
-pub struct TokenTreeIter(proc_macro::TokenTreeIter);
+pub struct TokenTreeIter(proc_macro::token_stream::IntoIter);
impl IntoIterator for TokenStream {
type Item = TokenTree;
type IntoIter = TokenTreeIter;
fn into_iter(self) -> TokenTreeIter {
TokenTreeIter(self.0.into_iter())
}
}
impl Iterator for TokenTreeIter {
type Item = TokenTree;
fn next(&mut self) -> Option<TokenTree> {
- let token = match self.0.next() {
- Some(n) => n,
- None => return None,
- };
- Some(TokenTree {
- span: ::Span(Span(token.span)),
- kind: match token.kind {
- proc_macro::TokenNode::Group(delim, s) => {
- let delim = match delim {
- proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
- proc_macro::Delimiter::Bracket => Delimiter::Bracket,
- proc_macro::Delimiter::Brace => Delimiter::Brace,
- proc_macro::Delimiter::None => Delimiter::None,
- };
- TokenNode::Group(delim, ::TokenStream(TokenStream(s)))
- }
- proc_macro::TokenNode::Op(ch, kind) => {
- let kind = match kind {
- proc_macro::Spacing::Joint => Spacing::Joint,
- proc_macro::Spacing::Alone => Spacing::Alone,
- };
- TokenNode::Op(ch, kind)
- }
- proc_macro::TokenNode::Term(s) => {
- TokenNode::Term(::Term(Term(s)))
- }
- proc_macro::TokenNode::Literal(l) => {
- TokenNode::Literal(::Literal(Literal(l)))
- }
- },
+ let token = self.0.next()?;
+ Some(match token {
+ proc_macro::TokenTree::Group(tt) => {
+ let delim = match tt.delimiter() {
+ proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
+ proc_macro::Delimiter::Bracket => Delimiter::Bracket,
+ proc_macro::Delimiter::Brace => Delimiter::Brace,
+ proc_macro::Delimiter::None => Delimiter::None,
+ };
+ let stream = ::TokenStream::_new(TokenStream(tt.stream()));
+ let mut g = Group::new(delim, stream);
+ g.set_span(::Span::_new(Span(tt.span())));
+ g.into()
+ }
+ proc_macro::TokenTree::Op(tt) => {
+ let spacing = match tt.spacing() {
+ proc_macro::Spacing::Joint => Spacing::Joint,
+ proc_macro::Spacing::Alone => Spacing::Alone,
+ };
+ let mut o = Op::new(tt.op(), spacing);
+ o.set_span(::Span::_new(Span(tt.span())));
+ o.into()
+ }
+ proc_macro::TokenTree::Term(s) => {
+ ::Term::_new(Term {
+ term: s,
+ }).into()
+ }
+ proc_macro::TokenTree::Literal(l) => {
+ ::Literal::_new(Literal {
+ lit: l,
+ }).into()
+ }
})
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.0.size_hint()
}
}
impl fmt::Debug for TokenTreeIter {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("TokenTreeIter").finish()
}
}
-#[cfg(procmacro2_semver_exempt)]
#[derive(Clone, PartialEq, Eq)]
pub struct FileName(String);
-#[cfg(procmacro2_semver_exempt)]
impl fmt::Display for FileName {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
// NOTE: We have to generate our own filename object here because we can't wrap
// the one provided by proc_macro.
-#[cfg(procmacro2_semver_exempt)]
#[derive(Clone, PartialEq, Eq)]
pub struct SourceFile(proc_macro::SourceFile, FileName);
-#[cfg(procmacro2_semver_exempt)]
impl SourceFile {
fn new(sf: proc_macro::SourceFile) -> Self {
let filename = FileName(sf.path().to_string());
SourceFile(sf, filename)
}
/// Get the path to this source file as a string.
pub fn path(&self) -> &FileName {
&self.1
}
pub fn is_real(&self) -> bool {
self.0.is_real()
}
}
-#[cfg(procmacro2_semver_exempt)]
impl AsRef<FileName> for SourceFile {
fn as_ref(&self) -> &FileName {
self.path()
}
}
-#[cfg(procmacro2_semver_exempt)]
impl fmt::Debug for SourceFile {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
-#[cfg(procmacro2_semver_exempt)]
pub struct LineColumn {
pub line: usize,
pub column: usize,
}
#[derive(Copy, Clone)]
pub struct Span(proc_macro::Span);
impl From<proc_macro::Span> for ::Span {
fn from(proc_span: proc_macro::Span) -> ::Span {
- ::Span(Span(proc_span))
+ ::Span::_new(Span(proc_span))
}
}
impl Span {
pub fn call_site() -> Span {
Span(proc_macro::Span::call_site())
}
@@ -237,170 +234,166 @@ impl Span {
pub fn located_at(&self, other: Span) -> Span {
Span(self.0.located_at(other.0))
}
pub fn unstable(self) -> proc_macro::Span {
self.0
}
- #[cfg(procmacro2_semver_exempt)]
pub fn source_file(&self) -> SourceFile {
SourceFile::new(self.0.source_file())
}
- #[cfg(procmacro2_semver_exempt)]
pub fn start(&self) -> LineColumn {
- let proc_macro::LineColumn{ line, column } = self.0.start();
+ let proc_macro::LineColumn { line, column } = self.0.start();
LineColumn { line, column }
}
- #[cfg(procmacro2_semver_exempt)]
pub fn end(&self) -> LineColumn {
- let proc_macro::LineColumn{ line, column } = self.0.end();
+ let proc_macro::LineColumn { line, column } = self.0.end();
LineColumn { line, column }
}
- #[cfg(procmacro2_semver_exempt)]
pub fn join(&self, other: Span) -> Option<Span> {
self.0.join(other.0).map(Span)
}
+
+ pub fn eq(&self, other: &Span) -> bool {
+ self.0.eq(&other.0)
+ }
}
impl fmt::Debug for Span {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.0.fmt(f)
}
}
#[derive(Copy, Clone)]
-pub struct Term(proc_macro::Term);
+pub struct Term {
+ term: proc_macro::Term,
+}
impl Term {
- pub fn intern(string: &str) -> Term {
- Term(proc_macro::Term::intern(string))
+ pub fn new(string: &str, span: Span) -> Term {
+ Term {
+ term: proc_macro::Term::new(string, span.0),
+ }
}
pub fn as_str(&self) -> &str {
- self.0.as_str()
+ self.term.as_str()
+ }
+
+ pub fn span(&self) -> Span {
+ Span(self.term.span())
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.term.set_span(span.0);
}
}
impl fmt::Debug for Term {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
+ self.term.fmt(f)
}
}
#[derive(Clone)]
-pub struct Literal(proc_macro::Literal);
+pub struct Literal {
+ lit: proc_macro::Literal,
+}
+
+macro_rules! suffixed_numbers {
+ ($($name:ident => $kind:ident,)*) => ($(
+ pub fn $name(n: $kind) -> Literal {
+ Literal::_new(proc_macro::Literal::$name(n))
+ }
+ )*)
+}
+
+macro_rules! unsuffixed_integers {
+ ($($name:ident => $kind:ident,)*) => ($(
+ pub fn $name(n: $kind) -> Literal {
+ Literal::_new(proc_macro::Literal::$name(n))
+ }
+ )*)
+}
impl Literal {
- pub fn byte_char(byte: u8) -> Literal {
- match byte {
- 0 => Literal(to_literal("b'\\0'")),
- b'\"' => Literal(to_literal("b'\"'")),
- n => {
- let mut escaped = "b'".to_string();
- escaped.extend(ascii::escape_default(n).map(|c| c as char));
- escaped.push('\'');
- Literal(to_literal(&escaped))
- }
+ fn _new(lit: proc_macro::Literal) -> Literal {
+ Literal {
+ lit,
}
}
+ suffixed_numbers! {
+ u8_suffixed => u8,
+ u16_suffixed => u16,
+ u32_suffixed => u32,
+ u64_suffixed => u64,
+ usize_suffixed => usize,
+ i8_suffixed => i8,
+ i16_suffixed => i16,
+ i32_suffixed => i32,
+ i64_suffixed => i64,
+ isize_suffixed => isize,
+
+ f32_suffixed => f32,
+ f64_suffixed => f64,
+ }
+
+ unsuffixed_integers! {
+ u8_unsuffixed => u8,
+ u16_unsuffixed => u16,
+ u32_unsuffixed => u32,
+ u64_unsuffixed => u64,
+ usize_unsuffixed => usize,
+ i8_unsuffixed => i8,
+ i16_unsuffixed => i16,
+ i32_unsuffixed => i32,
+ i64_unsuffixed => i64,
+ isize_unsuffixed => isize,
+ }
+
+ pub fn f32_unsuffixed(f: f32) -> Literal {
+ Literal::_new(proc_macro::Literal::f32_unsuffixed(f))
+ }
+
+ pub fn f64_unsuffixed(f: f64) -> Literal {
+ Literal::_new(proc_macro::Literal::f64_unsuffixed(f))
+ }
+
+
+ pub fn string(t: &str) -> Literal {
+ Literal::_new(proc_macro::Literal::string(t))
+ }
+
+ pub fn character(t: char) -> Literal {
+ Literal::_new(proc_macro::Literal::character(t))
+ }
+
pub fn byte_string(bytes: &[u8]) -> Literal {
- Literal(proc_macro::Literal::byte_string(bytes))
- }
-
- pub fn doccomment(s: &str) -> Literal {
- Literal(to_literal(s))
- }
-
- pub fn float(s: f64) -> Literal {
- Literal(proc_macro::Literal::float(s))
- }
-
- pub fn integer(s: i64) -> Literal {
- Literal(proc_macro::Literal::integer(s.into()))
+ Literal::_new(proc_macro::Literal::byte_string(bytes))
}
- pub fn raw_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("r");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(to_literal(&ret))
+ pub fn span(&self) -> Span {
+ Span(self.lit.span())
}
- pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("br");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(to_literal(&ret))
+ pub fn set_span(&mut self, span: Span) {
+ self.lit.set_span(span.0);
}
}
impl fmt::Display for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
+ self.lit.fmt(f)
}
}
impl fmt::Debug for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
- }
-}
-
-fn to_literal(s: &str) -> proc_macro::Literal {
- let stream = s.parse::<proc_macro::TokenStream>().unwrap();
- match stream.into_iter().next().unwrap().kind {
- proc_macro::TokenNode::Literal(l) => l,
- _ => unreachable!(),
+ self.lit.fmt(f)
}
}
-
-macro_rules! ints {
- ($($t:ident,)*) => {$(
- impl From<$t> for Literal {
- fn from(t: $t) -> Literal {
- Literal(proc_macro::Literal::$t(t))
- }
- }
- )*}
-}
-
-ints! {
- u8, u16, u32, u64, usize,
- i8, i16, i32, i64, isize,
-}
-
-macro_rules! floats {
- ($($t:ident,)*) => {$(
- impl From<$t> for Literal {
- fn from(t: $t) -> Literal {
- Literal(proc_macro::Literal::$t(t))
- }
- }
- )*}
-}
-
-floats! {
- f32, f64,
-}
-
-impl<'a> From<&'a str> for Literal {
- fn from(t: &'a str) -> Literal {
- Literal(proc_macro::Literal::string(t))
- }
-}
-
-impl From<char> for Literal {
- fn from(t: char) -> Literal {
- Literal(proc_macro::Literal::character(t))
- }
-}
--- a/third_party/rust/proc-macro2/tests/test.rs
+++ b/third_party/rust/proc-macro2/tests/test.rs
@@ -1,65 +1,125 @@
extern crate proc_macro2;
-use std::str;
+use std::str::{self, FromStr};
+
+use proc_macro2::{Literal, Span, Term, TokenStream, TokenTree};
-use proc_macro2::{Term, Literal, TokenStream};
+#[test]
+fn terms() {
+ assert_eq!(Term::new("String", Span::call_site()).as_str(), "String");
+ assert_eq!(Term::new("fn", Span::call_site()).as_str(), "fn");
+ assert_eq!(Term::new("_", Span::call_site()).as_str(), "_");
+}
+
+#[test]
+fn raw_terms() {
+ assert_eq!(Term::new("r#String", Span::call_site()).as_str(), "r#String");
+ assert_eq!(Term::new("r#fn", Span::call_site()).as_str(), "r#fn");
+ assert_eq!(Term::new("r#_", Span::call_site()).as_str(), "r#_");
+}
-#[cfg(procmacro2_semver_exempt)]
-use proc_macro2::TokenNode;
+#[test]
+fn lifetimes() {
+ assert_eq!(Term::new("'a", Span::call_site()).as_str(), "'a");
+ assert_eq!(Term::new("'static", Span::call_site()).as_str(), "'static");
+ assert_eq!(Term::new("'_", Span::call_site()).as_str(), "'_");
+}
-#[cfg(procmacro2_semver_exempt)]
-#[cfg(not(feature = "nightly"))]
-use proc_macro2::Span;
+#[test]
+#[should_panic(expected = "Term is not allowed to be empty; use Option<Term>")]
+fn term_empty() {
+ Term::new("", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Term cannot be a number; use Literal instead")]
+fn term_number() {
+ Term::new("255", Span::call_site());
+}
#[test]
-fn symbols() {
- assert_eq!(Term::intern("foo").as_str(), "foo");
- assert_eq!(Term::intern("bar").as_str(), "bar");
+#[should_panic(expected = "\"a#\" is not a valid Term")]
+fn term_invalid() {
+ Term::new("a#", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Term is not allowed to be empty; use Option<Term>")]
+fn raw_term_empty() {
+ Term::new("r#", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Term cannot be a number; use Literal instead")]
+fn raw_term_number() {
+ Term::new("r#255", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "\"r#a#\" is not a valid Term")]
+fn raw_term_invalid() {
+ Term::new("r#a#", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Term is not allowed to be empty; use Option<Term>")]
+fn lifetime_empty() {
+ Term::new("'", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Term cannot be a number; use Literal instead")]
+fn lifetime_number() {
+ Term::new("'255", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = r#""\'a#" is not a valid Term"#)]
+fn lifetime_invalid() {
+ Term::new("'a#", Span::call_site());
}
#[test]
fn literals() {
assert_eq!(Literal::string("foo").to_string(), "\"foo\"");
assert_eq!(Literal::string("\"").to_string(), "\"\\\"\"");
- assert_eq!(Literal::float(10.0).to_string(), "10.0");
+ assert_eq!(Literal::f32_unsuffixed(10.0).to_string(), "10.0");
}
#[test]
fn roundtrip() {
fn roundtrip(p: &str) {
println!("parse: {}", p);
let s = p.parse::<TokenStream>().unwrap().to_string();
println!("first: {}", s);
let s2 = s.to_string().parse::<TokenStream>().unwrap().to_string();
assert_eq!(s, s2);
}
roundtrip("a");
roundtrip("<<");
roundtrip("<<=");
- roundtrip("
- /// a
- wut
- ");
- roundtrip("
+ roundtrip(
+ "
1
1.0
1f32
2f64
1usize
4isize
4e10
1_000
1_0i32
8u8
9
0
0xffffffffffffffffffffffffffffffff
- ");
+ ",
+ );
roundtrip("'a");
roundtrip("'static");
roundtrip("'\\u{10__FFFF}'");
roundtrip("\"\\u{10_F0FF__}foo\\u{1_0_0_0__}\"");
}
#[test]
fn fail() {
@@ -68,64 +128,73 @@ fn fail() {
panic!("should have failed to parse: {}", p);
}
}
fail("1x");
fail("1u80");
fail("1f320");
fail("' static");
fail("'mut");
+ fail("r#1");
+ fail("r#_");
}
#[cfg(procmacro2_semver_exempt)]
#[test]
fn span_test() {
+ use proc_macro2::TokenTree;
+
fn check_spans(p: &str, mut lines: &[(usize, usize, usize, usize)]) {
let ts = p.parse::<TokenStream>().unwrap();
check_spans_internal(ts, &mut lines);
}
- fn check_spans_internal(
- ts: TokenStream,
- lines: &mut &[(usize, usize, usize, usize)],
- ) {
+ fn check_spans_internal(ts: TokenStream, lines: &mut &[(usize, usize, usize, usize)]) {
for i in ts {
if let Some((&(sline, scol, eline, ecol), rest)) = lines.split_first() {
*lines = rest;
- let start = i.span.start();
+ let start = i.span().start();
assert_eq!(start.line, sline, "sline did not match for {}", i);
assert_eq!(start.column, scol, "scol did not match for {}", i);
- let end = i.span.end();
+ let end = i.span().end();
assert_eq!(end.line, eline, "eline did not match for {}", i);
assert_eq!(end.column, ecol, "ecol did not match for {}", i);
- match i.kind {
- TokenNode::Group(_, stream) =>
- check_spans_internal(stream, lines),
+ match i {
+ TokenTree::Group(ref g) => {
+ check_spans_internal(g.stream().clone(), lines);
+ }
_ => {}
}
}
}
}
- check_spans("\
+ check_spans(
+ "\
/// This is a document comment
testing 123
{
testing 234
-}", &[
- (1, 0, 1, 30),
- (2, 0, 2, 7),
- (2, 8, 2, 11),
- (3, 0, 5, 1),
- (4, 2, 4, 9),
- (4, 10, 4, 13),
-]);
+}",
+ &[
+ (1, 0, 1, 30), // #
+ (1, 0, 1, 30), // [ ... ]
+ (1, 0, 1, 30), // doc
+ (1, 0, 1, 30), // =
+ (1, 0, 1, 30), // "This is..."
+ (2, 0, 2, 7), // testing
+ (2, 8, 2, 11), // 123
+ (3, 0, 5, 1), // { ... }
+ (4, 2, 4, 9), // testing
+ (4, 10, 4, 13), // 234
+ ],
+ );
}
#[cfg(procmacro2_semver_exempt)]
#[cfg(not(feature = "nightly"))]
#[test]
fn default_span() {
let start = Span::call_site().start();
assert_eq!(start.line, 1);
@@ -136,44 +205,100 @@ fn default_span() {
let source_file = Span::call_site().source_file();
assert_eq!(source_file.path().to_string(), "<unspecified>");
assert!(!source_file.is_real());
}
#[cfg(procmacro2_semver_exempt)]
#[test]
fn span_join() {
- let source1 =
- "aaa\nbbb".parse::<TokenStream>().unwrap().into_iter().collect::<Vec<_>>();
- let source2 =
- "ccc\nddd".parse::<TokenStream>().unwrap().into_iter().collect::<Vec<_>>();
+ let source1 = "aaa\nbbb"
+ .parse::<TokenStream>()
+ .unwrap()
+ .into_iter()
+ .collect::<Vec<_>>();
+ let source2 = "ccc\nddd"
+ .parse::<TokenStream>()
+ .unwrap()
+ .into_iter()
+ .collect::<Vec<_>>();
- assert!(source1[0].span.source_file() != source2[0].span.source_file());
- assert_eq!(source1[0].span.source_file(), source1[1].span.source_file());
+ assert!(source1[0].span().source_file() != source2[0].span().source_file());
+ assert_eq!(
+ source1[0].span().source_file(),
+ source1[1].span().source_file()
+ );
- let joined1 = source1[0].span.join(source1[1].span);
- let joined2 = source1[0].span.join(source2[0].span);
+ let joined1 = source1[0].span().join(source1[1].span());
+ let joined2 = source1[0].span().join(source2[0].span());
assert!(joined1.is_some());
assert!(joined2.is_none());
let start = joined1.unwrap().start();
let end = joined1.unwrap().end();
assert_eq!(start.line, 1);
assert_eq!(start.column, 0);
assert_eq!(end.line, 2);
assert_eq!(end.column, 3);
- assert_eq!(joined1.unwrap().source_file(), source1[0].span.source_file());
+ assert_eq!(
+ joined1.unwrap().source_file(),
+ source1[0].span().source_file()
+ );
}
#[test]
fn no_panic() {
let s = str::from_utf8(b"b\'\xc2\x86 \x00\x00\x00^\"").unwrap();
assert!(s.parse::<proc_macro2::TokenStream>().is_err());
}
#[test]
-fn tricky_doc_commaent() {
+fn tricky_doc_comment() {
let stream = "/**/".parse::<proc_macro2::TokenStream>().unwrap();
let tokens = stream.into_iter().collect::<Vec<_>>();
assert!(tokens.is_empty(), "not empty -- {:?}", tokens);
+
+ let stream = "/// doc".parse::<proc_macro2::TokenStream>().unwrap();
+ let tokens = stream.into_iter().collect::<Vec<_>>();
+ assert!(tokens.len() == 2, "not length 2 -- {:?}", tokens);
+ match tokens[0] {
+ proc_macro2::TokenTree::Op(ref tt) => assert_eq!(tt.op(), '#'),
+ _ => panic!("wrong token {:?}", tokens[0]),
+ }
+ let mut tokens = match tokens[1] {
+ proc_macro2::TokenTree::Group(ref tt) => {
+ assert_eq!(tt.delimiter(), proc_macro2::Delimiter::Bracket);
+ tt.stream().into_iter()
+ }
+ _ => panic!("wrong token {:?}", tokens[0]),
+ };
+
+ match tokens.next().unwrap() {
+ proc_macro2::TokenTree::Term(ref tt) => assert_eq!(tt.as_str(), "doc"),
+ t => panic!("wrong token {:?}", t),
+ }
+ match tokens.next().unwrap() {
+ proc_macro2::TokenTree::Op(ref tt) => assert_eq!(tt.op(), '='),
+ t => panic!("wrong token {:?}", t),
+ }
+ match tokens.next().unwrap() {
+ proc_macro2::TokenTree::Literal(ref tt) => {
+ assert_eq!(tt.to_string(), "\" doc\"");
+ }
+ t => panic!("wrong token {:?}", t),
+ }
+ assert!(tokens.next().is_none());
+
+ let stream = "//! doc".parse::<proc_macro2::TokenStream>().unwrap();
+ let tokens = stream.into_iter().collect::<Vec<_>>();
+ assert!(tokens.len() == 3, "not length 3 -- {:?}", tokens);
}
+#[test]
+fn raw_identifier() {
+ let mut tts = TokenStream::from_str("r#dyn").unwrap().into_iter();
+ match tts.next().unwrap() {
+ TokenTree::Term(raw) => assert_eq!("r#dyn", raw.as_str()),
+ wrong => panic!("wrong token {:?}", wrong),
+ }
+ assert!(tts.next().is_none());
+}
copy from third_party/rust/quote/.cargo-checksum.json
copy to third_party/rust/quote-0.4.2/.cargo-checksum.json
copy from third_party/rust/quote/Cargo.toml
copy to third_party/rust/quote-0.4.2/Cargo.toml
rename from third_party/rust/synom/LICENSE-APACHE
rename to third_party/rust/quote-0.4.2/LICENSE-APACHE
rename from third_party/rust/syn-0.11.11/LICENSE-MIT
rename to third_party/rust/quote-0.4.2/LICENSE-MIT
copy from third_party/rust/quote/README.md
copy to third_party/rust/quote-0.4.2/README.md
copy from third_party/rust/quote/src/lib.rs
copy to third_party/rust/quote-0.4.2/src/lib.rs
copy from third_party/rust/quote/src/to_tokens.rs
copy to third_party/rust/quote-0.4.2/src/to_tokens.rs
copy from third_party/rust/quote/src/tokens.rs
copy to third_party/rust/quote-0.4.2/src/tokens.rs
copy from third_party/rust/quote/tests/test.rs
copy to third_party/rust/quote-0.4.2/tests/test.rs
--- a/third_party/rust/quote/.cargo-checksum.json
+++ b/third_party/rust/quote/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"c8e98953df6fdcc4bdf6a1b7d970c214e8f5eb0f21da327d1c0916735303cd3a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"f1812dcc3e666d6bebca97f3739058e1bd8de1a2542c9a8cb258d0a259bd59e1","src/lib.rs":"b63a044edeff7ae12d0733e0a7fe64babf9b593b624fa753639ad3f340f24031","src/to_tokens.rs":"3b7fe0934ce2d9c23d9851ec624349cfa6e9d5cd9ed31c67f25cecce50dc218f","src/tokens.rs":"963474535197c1a79bf60af570470e7a89dce43546ee3186920197fdb40bdd9b","tests/test.rs":"8db237707035f55af7c7ef82c2c3892a048411963dccd019da0148bacae8c3d2"},"package":"1eca14c727ad12702eb4b6bfb5a232287dcf8385cb8ca83a3eeaf6519c44c408"}
\ No newline at end of file
+{"files":{"Cargo.toml":"693459089a22ff7249a6bc2e6e9a7fd0b2413a67d91872b4d635159f6da0f998","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"bdb5b5375e8cd37b75b4e0269b8fa9fb22776df9762c1df11ec88eb4cd2dc097","src/lib.rs":"05bc9cac79ba5e0084876e37b49178e7147b351786552e464d2beafd1ee84243","src/to_tokens.rs":"77287ca901b02f988b208f5138dc70bea03473cca37e3014f901320a34e8974b","src/tokens.rs":"a4939fc092d6466d5a2e75474886152e880586b12e057c0d7bf7b3f22428b2de","tests/test.rs":"35bac59a637a8dc3919df51bfa0957b6f964f408cc63c7a81a3e759ab8557f55"},"package":"7b0ff51282f28dc1b53fd154298feaa2e77c5ea0dba68e1fd8b03b72fbe13d2a"}
\ No newline at end of file
--- a/third_party/rust/quote/Cargo.toml
+++ b/third_party/rust/quote/Cargo.toml
@@ -7,18 +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 = "quote"
-version = "0.4.2"
+version = "0.5.1"
authors = ["David Tolnay <dtolnay@gmail.com>"]
include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
description = "Quasi-quoting macro quote!(...)"
documentation = "https://docs.rs/quote/"
+readme = "README.md"
keywords = ["syn"]
license = "MIT/Apache-2.0"
repository = "https://github.com/dtolnay/quote"
[dependencies.proc-macro2]
-version = "0.2"
+version = "0.3"
+default-features = false
+
+[features]
+default = ["proc-macro"]
+proc-macro = ["proc-macro2/proc-macro"]
--- a/third_party/rust/quote/README.md
+++ b/third_party/rust/quote/README.md
@@ -3,17 +3,17 @@ Rust Quasi-Quoting
[](https://travis-ci.org/dtolnay/quote)
[](https://crates.io/crates/quote)
[](https://docs.rs/quote/)
This crate provides the [`quote!`] macro for turning Rust syntax tree data
structures into tokens of source code.
-[`quote!`]: https://docs.rs/quote/0.4/quote/macro.quote.html
+[`quote!`]: https://docs.rs/quote/0.5/quote/macro.quote.html
Procedural macros in Rust receive a stream of tokens as input, execute arbitrary
Rust code to determine how to manipulate those tokens, and produce a stream of
tokens to hand back to the compiler to compile into the caller's crate.
Quasi-quoting is a solution to one piece of that -- producing tokens to return
to the compiler.
The idea of quasi-quoting is that we write *code* that we treat as *data*.
@@ -28,40 +28,40 @@ This crate is motivated by the procedura
general-purpose Rust quasi-quoting library and is not specific to procedural
macros.
*Version requirement: Quote supports any compiler version back to Rust's very
first support for procedural macros in Rust 1.15.0.*
```toml
[dependencies]
-quote = "0.4"
+quote = "0.5"
```
```rust
#[macro_use]
extern crate quote;
```
## Syntax
The quote crate provides a [`quote!`] macro within which you can write Rust code
that gets packaged into a [`quote::Tokens`] and can be treated as data. You
should think of `Tokens` as representing a fragment of Rust source code. Call
`to_string()` on a `Tokens` to get back the fragment of source code as a string,
or call `into()` to stream them as a `TokenStream` back to the compiler in a
procedural macro.
-[`quote::Tokens`]: https://docs.rs/quote/0.4/quote/struct.Tokens.html
+[`quote::Tokens`]: https://docs.rs/quote/0.5/quote/struct.Tokens.html
Within the `quote!` macro, interpolation is done with `#var`. Any type
implementing the [`quote::ToTokens`] trait can be interpolated. This includes
most Rust primitive types as well as most of the syntax tree types from [`syn`].
-[`quote::ToTokens`]: https://docs.rs/quote/0.4/quote/trait.ToTokens.html
+[`quote::ToTokens`]: https://docs.rs/quote/0.5/quote/trait.ToTokens.html
[`syn`]: https://github.com/dtolnay/syn
```rust
let tokens = quote! {
struct SerializeWith #generics #where_clause {
value: &'a #field_ty,
phantom: ::std::marker::PhantomData<#item_ty>,
}
@@ -104,17 +104,17 @@ Any interpolated tokens preserve the `Sp
`ToTokens` implementation. Tokens that originate within a `quote!` invocation
are spanned with [`Span::def_site()`].
[`Span::def_site()`]: https://docs.rs/proc-macro2/0.2/proc_macro2/struct.Span.html#method.def_site
A different span can be provided explicitly through the [`quote_spanned!`]
macro.
-[`quote_spanned!`]: https://docs.rs/quote/0.4/quote/macro.quote_spanned.html
+[`quote_spanned!`]: https://docs.rs/quote/0.5/quote/macro.quote_spanned.html
### Recursion limit
The `quote!` macro relies on deep recursion so some large invocations may fail
with "recursion limit reached" when you compile. If it fails, bump up the
recursion limit by adding `#![recursion_limit = "128"]` to your crate. An even
higher limit may be necessary for especially large invocations. You don't need
this unless the compiler tells you that you need it.
--- a/third_party/rust/quote/src/lib.rs
+++ b/third_party/rust/quote/src/lib.rs
@@ -21,17 +21,17 @@
//! general-purpose Rust quasi-quoting library and is not specific to procedural
//! macros.
//!
//! *Version requirement: Quote supports any compiler version back to Rust's
//! very first support for procedural macros in Rust 1.15.0.*
//!
//! ```toml
//! [dependencies]
-//! quote = "0.4"
+//! quote = "0.5"
//! ```
//!
//! ```
//! #[macro_use]
//! extern crate quote;
//! #
//! # fn main() {}
//! ```
@@ -86,20 +86,21 @@
//! ## Recursion limit
//!
//! The `quote!` macro relies on deep recursion so some large invocations may
//! fail with "recursion limit reached" when you compile. If it fails, bump up
//! the recursion limit by adding `#![recursion_limit = "128"]` to your crate.
//! An even higher limit may be necessary for especially large invocations.
// Quote types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/quote/0.4.2")]
+#![doc(html_root_url = "https://docs.rs/quote/0.5.1")]
+#[cfg(feature = "proc-macro")]
+extern crate proc_macro;
extern crate proc_macro2;
-extern crate proc_macro;
mod tokens;
pub use tokens::Tokens;
mod to_tokens;
pub use to_tokens::ToTokens;
// Not public API.
@@ -107,28 +108,20 @@ pub use to_tokens::ToTokens;
pub mod __rt {
// Not public API.
pub use proc_macro2::*;
// Not public API.
pub fn parse(tokens: &mut ::Tokens, span: Span, s: &str) {
let s: TokenStream = s.parse().expect("invalid token stream");
tokens.append_all(s.into_iter().map(|mut t| {
- t.span = span;
+ t.set_span(span);
t
}));
}
-
- // Not public API.
- pub fn append_kind(tokens: &mut ::Tokens, span: Span, kind: TokenNode) {
- tokens.append(TokenTree {
- span: span,
- kind: kind,
- })
- }
}
/// The whole point.
///
/// Performs variable interpolation against the input and produces it as
/// [`Tokens`]. For returning tokens to the compiler in a procedural macro, use
/// `into()` to build a `TokenStream`.
///
@@ -153,28 +146,31 @@ pub mod __rt {
/// - `#(#var),*` — the character before the asterisk is used as a separator
/// - `#( struct #var; )*` — the repetition can contain other tokens
/// - `#( #k => println!("{}", #v), )*` — even multiple interpolations
///
/// # Hygiene
///
/// Any interpolated tokens preserve the `Span` information provided by their
/// `ToTokens` implementation. Tokens that originate within the `quote!`
-/// invocation are spanned with [`Span::def_site()`].
+/// invocation are spanned with [`Span::call_site()`].
///
-/// [`Span::def_site()`]: https://docs.rs/proc-macro2/0.2/proc_macro2/struct.Span.html#method.def_site
+/// [`Span::call_site()`]: https://docs.rs/proc-macro2/0.2/proc_macro2/struct.Span.html#method.call_site
///
/// A different span can be provided through the [`quote_spanned!`] macro.
///
/// [`quote_spanned!`]: macro.quote_spanned.html
///
/// # Example
///
/// ```
+/// # #[cfg(feature = "proc-macro")]
/// extern crate proc_macro;
+/// # #[cfg(not(feature = "proc-macro"))]
+/// # extern crate proc_macro2 as proc_macro;
///
/// #[macro_use]
/// extern crate quote;
///
/// use proc_macro::TokenStream;
///
/// # const IGNORE_TOKENS: &'static str = stringify! {
/// #[proc_macro_derive(HeapSize)]
@@ -201,17 +197,17 @@ pub mod __rt {
/// // Hand the output tokens back to the compiler.
/// expanded.into()
/// }
/// #
/// # fn main() {}
/// ```
#[macro_export]
macro_rules! quote {
- ($($tt:tt)*) => (quote_spanned!($crate::__rt::Span::def_site()=> $($tt)*));
+ ($($tt:tt)*) => (quote_spanned!($crate::__rt::Span::call_site()=> $($tt)*));
}
/// Same as `quote!`, but applies a given span to all tokens originating within
/// the macro invocation.
///
/// # Syntax
///
/// A span expression of type [`Span`], followed by `=>`, followed by the tokens
@@ -239,16 +235,22 @@ macro_rules! quote {
///
/// // On multiple lines, place the span at the top and use braces.
/// let tokens = quote_spanned! {span=>
/// Box::into_raw(Box::new(#init))
/// };
/// # }
/// ```
///
+/// The lack of space before the `=>` should look jarring to Rust programmers
+/// and this is intentional. The formatting is designed to be visibly
+/// off-balance and draw the eye a particular way, due to the span expression
+/// being evaluated in the context of the procedural macro and the remaining
+/// tokens being evaluated in the generated code.
+///
/// # Hygiene
///
/// Any interpolated tokens preserve the `Span` information provided by their
/// `ToTokens` implementation. Tokens that originate within the `quote_spanned!`
/// invocation are spanned with the given span argument.
///
/// # Example
///
@@ -275,19 +277,19 @@ macro_rules! quote {
/// # }
/// #
/// # impl ToTokens for Type {
/// # fn to_tokens(&self, _tokens: &mut Tokens) {}
/// # }
/// #
/// # fn main() {
/// # let ty = Type;
-/// # let def_site = Span::def_site();
+/// # let call_site = Span::call_site();
/// #
-/// let ty_span = ty.span().resolved_at(def_site);
+/// let ty_span = ty.span();
/// let assert_sync = quote_spanned! {ty_span=>
/// struct _AssertSync where #ty: Sync;
/// };
/// # }
/// ```
///
/// If the assertion fails, the user will see an error like the following. The
/// input span of their type is hightlighted in the error.
@@ -444,57 +446,65 @@ macro_rules! quote_each_token {
}
quote_each_token!($tokens $span $($inner)*);
}
quote_each_token!($tokens $span $($rest)*);
};
($tokens:ident $span:ident # [ $($inner:tt)* ] $($rest:tt)*) => {
quote_each_token!($tokens $span #);
- $crate::__rt::append_kind(&mut $tokens,
- $span,
- $crate::__rt::TokenNode::Group(
+ $tokens.append({
+ let mut g = $crate::__rt::Group::new(
$crate::__rt::Delimiter::Bracket,
- quote_spanned!($span=> $($inner)*).into()
- ));
+ quote_spanned!($span=> $($inner)*).into(),
+ );
+ g.set_span($span);
+ g
+ });
quote_each_token!($tokens $span $($rest)*);
};
($tokens:ident $span:ident # $first:ident $($rest:tt)*) => {
$crate::ToTokens::to_tokens(&$first, &mut $tokens);
quote_each_token!($tokens $span $($rest)*);
};
($tokens:ident $span:ident ( $($first:tt)* ) $($rest:tt)*) => {
- $crate::__rt::append_kind(&mut $tokens,
- $span,
- $crate::__rt::TokenNode::Group(
+ $tokens.append({
+ let mut g = $crate::__rt::Group::new(
$crate::__rt::Delimiter::Parenthesis,
- quote_spanned!($span=> $($first)*).into()
- ));
+ quote_spanned!($span=> $($first)*).into(),
+ );
+ g.set_span($span);
+ g
+ });
quote_each_token!($tokens $span $($rest)*);
};
($tokens:ident $span:ident [ $($first:tt)* ] $($rest:tt)*) => {
- $crate::__rt::append_kind(&mut $tokens,
- $span,
- $crate::__rt::TokenNode::Group(
+ $tokens.append({
+ let mut g = $crate::__rt::Group::new(
$crate::__rt::Delimiter::Bracket,
- quote_spanned!($span=> $($first)*).into()
- ));
+ quote_spanned!($span=> $($first)*).into(),
+ );
+ g.set_span($span);
+ g
+ });
quote_each_token!($tokens $span $($rest)*);
};
($tokens:ident $span:ident { $($first:tt)* } $($rest:tt)*) => {
- $crate::__rt::append_kind(&mut $tokens,
- $span,
- $crate::__rt::TokenNode::Group(
+ $tokens.append({
+ let mut g = $crate::__rt::Group::new(
$crate::__rt::Delimiter::Brace,
- quote_spanned!($span=> $($first)*).into()
- ));
+ quote_spanned!($span=> $($first)*).into(),
+ );
+ g.set_span($span);
+ g
+ });
quote_each_token!($tokens $span $($rest)*);
};
($tokens:ident $span:ident $first:tt $($rest:tt)*) => {
// TODO: this seems slow... special case some `:tt` arguments?
$crate::__rt::parse(&mut $tokens, $span, stringify!($first));
quote_each_token!($tokens $span $($rest)*);
};
--- a/third_party/rust/quote/src/to_tokens.rs
+++ b/third_party/rust/quote/src/to_tokens.rs
@@ -1,55 +1,42 @@
use super::Tokens;
use std::borrow::Cow;
-use proc_macro2::{Literal, Span, Term, TokenNode, TokenTree, TokenStream};
-
-fn tt(kind: TokenNode) -> TokenTree {
- TokenTree {
- span: Span::def_site(),
- kind: kind,
- }
-}
+use proc_macro2::{Literal, Span, Term, TokenStream, TokenTree};
/// Types that can be interpolated inside a [`quote!`] invocation.
///
/// [`quote!`]: macro.quote.html
pub trait ToTokens {
/// Write `self` to the given `Tokens`.
///
/// Example implementation for a struct representing Rust paths like
/// `std::cmp::PartialEq`:
///
/// ```
/// extern crate quote;
/// use quote::{Tokens, ToTokens};
///
/// extern crate proc_macro2;
- /// use proc_macro2::{TokenTree, TokenNode, Spacing, Span};
+ /// use proc_macro2::{TokenTree, Spacing, Span, Op};
///
/// pub struct Path {
/// pub global: bool,
/// pub segments: Vec<PathSegment>,
/// }
///
/// impl ToTokens for Path {
/// fn to_tokens(&self, tokens: &mut Tokens) {
/// for (i, segment) in self.segments.iter().enumerate() {
/// if i > 0 || self.global {
/// // Double colon `::`
- /// tokens.append(TokenTree {
- /// span: Span::def_site(),
- /// kind: TokenNode::Op(':', Spacing::Joint),
- /// });
- /// tokens.append(TokenTree {
- /// span: Span::def_site(),
- /// kind: TokenNode::Op(':', Spacing::Alone),
- /// });
+ /// tokens.append(Op::new(':', Spacing::Joint));
+ /// tokens.append(Op::new(':', Spacing::Alone));
/// }
/// segment.to_tokens(tokens);
/// }
/// }
/// }
/// #
/// # pub struct PathSegment;
/// #
@@ -100,70 +87,75 @@ impl<T: ToTokens> ToTokens for Option<T>
if let Some(ref t) = *self {
t.to_tokens(tokens);
}
}
}
impl ToTokens for str {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(tt(TokenNode::Literal(Literal::string(self))));
+ tokens.append(Literal::string(self));
}
}
impl ToTokens for String {
fn to_tokens(&self, tokens: &mut Tokens) {
self.as_str().to_tokens(tokens);
}
}
macro_rules! primitive {
- ($($t:ident)*) => ($(
+ ($($t:ident => $name:ident)*) => ($(
impl ToTokens for $t {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(tt(TokenNode::Literal(Literal::$t(*self))));
+ tokens.append(Literal::$name(*self));
}
}
)*)
}
primitive! {
- i8 i16 i32 i64 isize
- u8 u16 u32 u64 usize
- f32 f64
+ i8 => i8_suffixed
+ i16 => i16_suffixed
+ i32 => i32_suffixed
+ i64 => i64_suffixed
+ isize => isize_suffixed
+
+ u8 => u8_suffixed
+ u16 => u16_suffixed
+ u32 => u32_suffixed
+ u64 => u64_suffixed
+ usize => usize_suffixed
+
+ f32 => f32_suffixed
+ f64 => f64_suffixed
}
impl ToTokens for char {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(tt(TokenNode::Literal(Literal::character(*self))));
+ tokens.append(Literal::character(*self));
}
}
impl ToTokens for bool {
fn to_tokens(&self, tokens: &mut Tokens) {
let word = if *self { "true" } else { "false" };
- tokens.append(tt(TokenNode::Term(Term::intern(word))));
+ tokens.append(Term::new(word, Span::call_site()));
}
}
impl ToTokens for Term {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(tt(TokenNode::Term(*self)));
+ tokens.append(self.clone());
}
}
impl ToTokens for Literal {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(tt(TokenNode::Literal(self.clone())));
- }
-}
-
-impl ToTokens for TokenNode {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(tt(self.clone()));
+ tokens.append(self.clone());
}
}
impl ToTokens for TokenTree {
fn to_tokens(&self, dst: &mut Tokens) {
dst.append(self.clone());
}
}
--- a/third_party/rust/quote/src/tokens.rs
+++ b/third_party/rust/quote/src/tokens.rs
@@ -1,12 +1,13 @@
use super::ToTokens;
use std::fmt::{self, Debug, Display};
use std::hash::{Hash, Hasher};
+#[cfg(feature = "proc-macro")]
use proc_macro;
use proc_macro2::{TokenStream, TokenTree};
/// Tokens produced by a [`quote!`] invocation.
///
/// [`quote!`]: macro.quote.html
#[derive(Clone, Default)]
pub struct Tokens {
@@ -103,16 +104,17 @@ impl ToTokens for Tokens {
}
impl From<Tokens> for TokenStream {
fn from(tokens: Tokens) -> TokenStream {
tokens.tts.into_iter().collect()
}
}
+#[cfg(feature = "proc-macro")]
impl From<Tokens> for proc_macro::TokenStream {
fn from(tokens: Tokens) -> proc_macro::TokenStream {
TokenStream::from(tokens).into()
}
}
/// Allows a `Tokens` to be passed to `Tokens::append_all`.
impl IntoIterator for Tokens {
@@ -120,18 +122,18 @@ impl IntoIterator for Tokens {
type IntoIter = private::IntoIter;
fn into_iter(self) -> Self::IntoIter {
private::into_iter(self.tts.into_iter())
}
}
mod private {
+ use proc_macro2::TokenTree;
use std::vec;
- use proc_macro2::TokenTree;
pub struct IntoIter(vec::IntoIter<TokenTree>);
pub fn into_iter(tts: vec::IntoIter<TokenTree>) -> IntoIter {
IntoIter(tts)
}
impl Iterator for IntoIter {
@@ -165,52 +167,52 @@ impl Debug for Tokens {
formatter
.debug_tuple("Tokens")
.field(&DebugAsDisplay(self))
.finish()
}
}
fn tt_eq(a: &TokenTree, b: &TokenTree) -> bool {
- use proc_macro2::{TokenNode, Delimiter, Spacing};
+ use proc_macro2::{Delimiter, Spacing};
- match (&a.kind, &b.kind) {
- (&TokenNode::Group(d1, ref s1), &TokenNode::Group(d2, ref s2)) => {
- match (d1, d2) {
+ match (a, b) {
+ (&TokenTree::Group(ref s1), &TokenTree::Group(ref s2)) => {
+ match (s1.delimiter(), s2.delimiter()) {
(Delimiter::Parenthesis, Delimiter::Parenthesis)
| (Delimiter::Brace, Delimiter::Brace)
| (Delimiter::Bracket, Delimiter::Bracket)
| (Delimiter::None, Delimiter::None) => {}
_ => return false,
}
- let s1 = s1.clone().into_iter();
- let mut s2 = s2.clone().into_iter();
+ let s1 = s1.stream().clone().into_iter();
+ let mut s2 = s2.stream().clone().into_iter();
for item1 in s1 {
let item2 = match s2.next() {
Some(item) => item,
None => return false,
};
if !tt_eq(&item1, &item2) {
return false;
}
}
s2.next().is_none()
}
- (&TokenNode::Op(o1, k1), &TokenNode::Op(o2, k2)) => {
- o1 == o2 && match (k1, k2) {
+ (&TokenTree::Op(ref o1), &TokenTree::Op(ref o2)) => {
+ o1.op() == o2.op() && match (o1.spacing(), o2.spacing()) {
(Spacing::Alone, Spacing::Alone) | (Spacing::Joint, Spacing::Joint) => true,
_ => false,
}
}
- (&TokenNode::Literal(ref l1), &TokenNode::Literal(ref l2)) => {
+ (&TokenTree::Literal(ref l1), &TokenTree::Literal(ref l2)) => {
l1.to_string() == l2.to_string()
}
- (&TokenNode::Term(ref s1), &TokenNode::Term(ref s2)) => s1.as_str() == s2.as_str(),
+ (&TokenTree::Term(ref s1), &TokenTree::Term(ref s2)) => s1.as_str() == s2.as_str(),
_ => false,
}
}
impl PartialEq for Tokens {
fn eq(&self, other: &Self) -> bool {
if self.tts.len() != other.tts.len() {
return false;
@@ -219,43 +221,43 @@ impl PartialEq for Tokens {
self.tts
.iter()
.zip(other.tts.iter())
.all(|(a, b)| tt_eq(a, b))
}
}
fn tt_hash<H: Hasher>(tt: &TokenTree, h: &mut H) {
- use proc_macro2::{TokenNode, Delimiter, Spacing};
+ use proc_macro2::{Delimiter, Spacing};
- match tt.kind {
- TokenNode::Group(delim, ref stream) => {
+ match *tt {
+ TokenTree::Group(ref g) => {
0u8.hash(h);
- match delim {
+ match g.delimiter() {
Delimiter::Parenthesis => 0u8.hash(h),
Delimiter::Brace => 1u8.hash(h),
Delimiter::Bracket => 2u8.hash(h),
Delimiter::None => 3u8.hash(h),
}
- for item in stream.clone() {
+ for item in g.stream().clone() {
tt_hash(&item, h);
}
0xffu8.hash(h); // terminator w/ a variant we don't normally hash
}
- TokenNode::Op(op, kind) => {
+ TokenTree::Op(ref t) => {
1u8.hash(h);
- op.hash(h);
- match kind {
+ t.op().hash(h);
+ match t.spacing() {
Spacing::Alone => 0u8.hash(h),
Spacing::Joint => 1u8.hash(h),
}
}
- TokenNode::Literal(ref lit) => (2u8, lit.to_string()).hash(h),
- TokenNode::Term(ref word) => (3u8, word.as_str()).hash(h),
+ TokenTree::Literal(ref lit) => (2u8, lit.to_string()).hash(h),
+ TokenTree::Term(ref word) => (3u8, word.as_str()).hash(h),
}
}
impl<'a> Hash for Tokens {
fn hash<H: Hasher>(&self, h: &mut H) {
self.tts.len().hash(h);
for tt in &self.tts {
tt_hash(&tt, h);
--- a/third_party/rust/quote/tests/test.rs
+++ b/third_party/rust/quote/tests/test.rs
@@ -7,32 +7,29 @@ extern crate proc_macro2;
extern crate quote;
use proc_macro2::{Span, Term};
struct X;
impl quote::ToTokens for X {
fn to_tokens(&self, tokens: &mut quote::Tokens) {
- tokens.append(proc_macro2::TokenTree {
- kind: proc_macro2::TokenNode::Term(Term::intern("X")),
- span: Span::def_site(),
- });
+ tokens.append(Term::new("X", Span::call_site()));
}
}
#[test]
fn test_quote_impl() {
- let tokens = quote!(
+ let tokens = quote! {
impl<'a, T: ToTokens> ToTokens for &'a T {
fn to_tokens(&self, tokens: &mut Tokens) {
(**self).to_tokens(tokens)
}
}
- );
+ };
let expected = concat!(
"impl < 'a , T : ToTokens > ToTokens for & 'a T { ",
"fn to_tokens ( & self , tokens : & mut Tokens ) { ",
"( * * self ) . to_tokens ( tokens ) ",
"} ",
"}"
);
@@ -180,18 +177,18 @@ fn test_string() {
let s = "\0 a 'b \" c".to_string();
let tokens = quote!(#s);
let expected = "\"\\u{0} a \\'b \\\" c\"";
assert_eq!(expected, tokens.to_string());
}
#[test]
fn test_ident() {
- let foo = Term::intern("Foo");
- let bar = Term::intern(&format!("Bar{}", 7));
+ let foo = Term::new("Foo", Span::call_site());
+ let bar = Term::new(&format!("Bar{}", 7), Span::call_site());
let tokens = quote!(struct #foo; enum #bar {});
let expected = "struct Foo ; enum Bar7 { }";
assert_eq!(expected, tokens.to_string());
}
#[test]
fn test_duplicate() {
let ch = 'x';
@@ -255,29 +252,29 @@ fn test_empty_quote() {
fn test_box_str() {
let b = "str".to_owned().into_boxed_str();
let tokens = quote! { #b };
assert_eq!("\"str\"", tokens.to_string());
}
#[test]
fn test_cow() {
- let owned: Cow<Term> = Cow::Owned(Term::intern("owned"));
+ let owned: Cow<Term> = Cow::Owned(Term::new("owned", Span::call_site()));
- let ident = Term::intern("borrowed");
+ let ident = Term::new("borrowed", Span::call_site());
let borrowed = Cow::Borrowed(&ident);
let tokens = quote! { #owned #borrowed };
assert_eq!("owned borrowed", tokens.to_string());
}
#[test]
fn test_closure() {
fn field_i(i: usize) -> Term {
- Term::intern(&format!("__field{}", i))
+ Term::new(&format!("__field{}", i), Span::call_site())
}
let fields = (0usize..3)
.map(field_i as fn(_) -> _)
.map(|var| quote! { #var });
let tokens = quote! { #(#fields)* };
assert_eq!("__field0 __field1 __field2", tokens.to_string());
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{"Cargo.toml":"e1c76f5a888ab4a9047a9079a2c69a666170ef5bbdbd540720cbfe4b6c2a5b78","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"aa140842ad00ec4f0601fefdeef5046bfeae3834d58c9ba6d9721d65885fc016","src/aster/generics.rs":"030a8e7f4de881ef60c171fe48bcb65aec8d58f3558f755a3b9b953b2c9f1819","src/aster/ident.rs":"e9d082664f008a56bd854011310b4258ab072740ba82e57495b6e8a868a5f36b","src/aster/invoke.rs":"2b1b993973ab4f5c8fa6d6a286576b2542edce21fe9904f5133c470c072e6d3f","src/aster/lifetime.rs":"304101622e102586946802ae17a0a76d53a7f3a3e72e520d0e2ac3c8664db3ef","src/aster/mod.rs":"12220f73b0021e72b4c50f6a513cff174b9c7267209aa23f183043d96ccc9ab7","src/aster/path.rs":"7298bcbd522e10a48ec9d54a1959eec4a0b6368fda9ef10d6e19fc488507d5bb","src/aster/qpath.rs":"5ba33af56ccf74f5c516ed542d117d1f6ca9f7dfd1a74d08b4ac50d95666c497","src/aster/ty.rs":"07d783269047f3be20e73ccc962bb4c4cd63c869d73de8bae7bef25b53986d09","src/aster/ty_param.rs":"4f17c12e0b7cb306cfdfaea648eaccee5116923b2abb4d35d085d88f70c40385","src/aster/where_predicate.rs":"5fb8ec3fcb67bcc1d9bb7b64cf2f5beb601aac6502d6db30c0cdf8641fa248d1","src/attr.rs":"2c0c14c45f39af22ea10e0d15c24ef349b23408b6c4e24b6e91c48d38a5e5ca2","src/constant.rs":"b68686cdf371d76d7ac548184d52e46fa1312e84b02a5b504fedbbc54a3b26ff","src/data.rs":"1d6c3c29b1d94a01fb6ec41b4144c22a8ebd7a7fe9074d87fbe2fd1776f2f38b","src/derive.rs":"5d474fa52c19c4d46ff79be39038254887ca01f1786c0032b54e0b5ad8697b03","src/escape.rs":"7263b3df626ad26e5b82b329557584f7cdd61589977ce82c9e794e1b61f042b2","src/expr.rs":"77e22fbf2d1003366296a05d42806a69fdaaa73b4a02e6a99438d8fc886d06b6","src/fold.rs":"879928ea8de2b228f9073658ffa100c689ec85edabfa4f876f9aee3b13057522","src/generics.rs":"02ddd46f39d771d7f229d69f763278e75ee50a5af2c7d2746080e959639726f7","src/ident.rs":"9eb6354d2b58e14191e44592c122501232539b53480389ab9e35d426c3962123","src/item.rs":"c91ec1b423877590acd3fa01b094f452ef6b177db6c177056f33caf61f3fe92d","src/krate.rs":"78f89e1f12f5b790d99d88a3a013178585f6715a27eb26f604e72e763a47dfdf","src/lib.rs":"2931fc34ec99b9ce1776debaca8114eb3531c0851ca584239c03637c90b1cf7d","src/lit.rs":"f8cdfd540f038f699cb546fc3cfc43ec6f72551aa12ca351ea0beb9c8100fa4c","src/mac.rs":"b3ba8e7531980abecec4a9f86f68ae136c5982617e0e37aaa823d288ba6f5e4e","src/op.rs":"232f84ba605ed50e70ee02169dd551548872135cf56f155637917ec3bf810ce1","src/ty.rs":"d71d75de0c0a6d27bc1d425a4ce282e42f7d6126e34ecaa7798353dffb231229","src/visit.rs":"a0c4c7d9768bd5b8fab5441932fc4075e7dc827b73144e5972a04fc7c2e676ff"},"package":"d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/Cargo.toml
+++ /dev/null
@@ -1,30 +0,0 @@
-[package]
-name = "syn"
-version = "0.11.11" # don't forget to update version in readme for breaking changes
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
-description = "Nom parser for Rust source code"
-repository = "https://github.com/dtolnay/syn"
-documentation = "https://dtolnay.github.io/syn/syn/"
-categories = ["development-tools::procedural-macro-helpers"]
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-
-[features]
-default = ["parsing", "printing"]
-aster = []
-full = []
-parsing = ["unicode-xid", "synom"]
-printing = ["quote"]
-visit = []
-fold = []
-
-[dependencies]
-quote = { version = "0.3.7", optional = true }
-unicode-xid = { version = "0.0.4", optional = true }
-synom = { version = "0.11", path = "synom", optional = true }
-
-[dev-dependencies]
-syntex_pos = "0.58"
-syntex_syntax = "0.58"
-tempdir = "0.3.5"
-walkdir = "1.0.1"
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/README.md
+++ /dev/null
@@ -1,205 +0,0 @@
-Nom parser for Rust source code
-===============================
-
-[](https://travis-ci.org/dtolnay/syn)
-[](https://crates.io/crates/syn)
-[](https://dtolnay.github.io/syn/syn/)
-
-Parse Rust source code without a Syntex dependency, intended for use with
-[Macros 1.1](https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md).
-
-Designed for fast compile time.
-
-- Compile time for `syn` (from scratch including all dependencies): **6 seconds**
-- Compile time for the `syntex`/`quasi`/`aster` stack: **60+ seconds**
-
-If you get stuck with Macros 1.1 I am happy to provide help even if the issue is
-not related to syn. Please file a ticket in this repo.
-
-## Usage with Macros 1.1
-
-```toml
-[dependencies]
-syn = "0.11"
-quote = "0.3"
-
-[lib]
-proc-macro = true
-```
-
-```rust
-extern crate proc_macro;
-use proc_macro::TokenStream;
-
-extern crate syn;
-
-#[macro_use]
-extern crate quote;
-
-#[proc_macro_derive(MyMacro)]
-pub fn my_macro(input: TokenStream) -> TokenStream {
- let source = input.to_string();
-
- // Parse the string representation into a syntax tree
- let ast = syn::parse_derive_input(&source).unwrap();
-
- // Build the output, possibly using quasi-quotation
- let expanded = quote! {
- // ...
- };
-
- // Parse back to a token stream and return it
- expanded.parse().unwrap()
-}
-```
-
-## Complete example
-
-Suppose we have the following simple trait which returns the number of fields in
-a struct:
-
-```rust
-trait NumFields {
- fn num_fields() -> usize;
-}
-```
-
-A complete Macros 1.1 implementation of `#[derive(NumFields)]` based on `syn`
-and [`quote`](https://github.com/dtolnay/quote) looks like this:
-
-```rust
-extern crate proc_macro;
-use proc_macro::TokenStream;
-
-extern crate syn;
-
-#[macro_use]
-extern crate quote;
-
-#[proc_macro_derive(NumFields)]
-pub fn num_fields(input: TokenStream) -> TokenStream {
- let source = input.to_string();
-
- // Parse the string representation into a syntax tree
- let ast = syn::parse_derive_input(&source).unwrap();
-
- // Build the output
- let expanded = expand_num_fields(&ast);
-
- // Return the generated impl as a TokenStream
- expanded.parse().unwrap()
-}
-
-fn expand_num_fields(ast: &syn::DeriveInput) -> quote::Tokens {
- let n = match ast.body {
- syn::Body::Struct(ref data) => data.fields().len(),
- syn::Body::Enum(_) => panic!("#[derive(NumFields)] can only be used with structs"),
- };
-
- // Used in the quasi-quotation below as `#name`
- let name = &ast.ident;
-
- // Helper is provided for handling complex generic types correctly and effortlessly
- let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-
- quote! {
- // The generated impl
- impl #impl_generics ::mycrate::NumFields for #name #ty_generics #where_clause {
- fn num_fields() -> usize {
- #n
- }
- }
- }
-}
-```
-
-For a more elaborate example that involves trait bounds, enums, and different
-kinds of structs, check out [`DeepClone`] and [`deep-clone-derive`].
-
-[`DeepClone`]: https://github.com/asajeffrey/deep-clone
-[`deep-clone-derive`]: https://github.com/asajeffrey/deep-clone/blob/master/deep-clone-derive/lib.rs
-
-## Testing
-
-Macros 1.1 has a restriction that your proc-macro crate must export nothing but
-`proc_macro_derive` functions, and also `proc_macro_derive` procedural macros
-cannot be used from the same crate in which they are defined. These restrictions
-may be lifted in the future but for now they make writing tests a bit trickier
-than for other types of code.
-
-In particular, you will not be able to write test functions like `#[test] fn
-it_works() { ... }` in line with your code. Instead, either put tests in a
-[`tests` directory](https://doc.rust-lang.org/book/testing.html#the-tests-directory)
-or in a separate crate entirely.
-
-Additionally, if your procedural macro implements a particular trait, that trait
-must be defined in a separate crate from the procedural macro.
-
-As a concrete example, suppose your procedural macro crate is called `my_derive`
-and it implements a trait called `my_crate::MyTrait`. Your unit tests for the
-procedural macro can go in `my_derive/tests/test.rs` or into a separate crate
-`my_tests/tests/test.rs`. Either way the test would look something like this:
-
-```rust
-#[macro_use]
-extern crate my_derive;
-
-extern crate my_crate;
-use my_crate::MyTrait;
-
-#[test]
-fn it_works() {
- #[derive(MyTrait)]
- struct S { /* ... */ }
-
- /* test the thing */
-}
-```
-
-## Debugging
-
-When developing a procedural macro it can be helpful to look at what the
-generated code looks like. Use `cargo rustc -- -Zunstable-options
---pretty=expanded` or the
-[`cargo expand`](https://github.com/dtolnay/cargo-expand) subcommand.
-
-To show the expanded code for some crate that uses your procedural macro, run
-`cargo expand` from that crate. To show the expanded code for one of your own
-test cases, run `cargo expand --test the_test_case` where the last argument is
-the name of the test file without the `.rs` extension.
-
-This write-up by Brandon W Maister discusses debugging in more detail:
-[Debugging Rust's new Custom Derive
-system](https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system/).
-
-## Optional features
-
-Syn puts a lot of functionality behind optional features in order to optimize
-compile time for the most common use cases. These are the available features and
-their effect on compile time. Dependencies are included in the compile times.
-
-Features | Compile time | Functionality
---- | --- | ---
-*(none)* | 3 sec | The data structures representing the AST of Rust structs, enums, and types.
-parsing | 6 sec | Parsing Rust source code containing structs and enums into an AST.
-printing | 4 sec | Printing an AST of structs and enums as Rust source code.
-**parsing, printing** | **6 sec** | **This is the default.** Parsing and printing of Rust structs and enums. This is typically what you want for implementing Macros 1.1 custom derives.
-full | 4 sec | The data structures representing the full AST of all possible Rust code.
-full, parsing | 9 sec | Parsing any valid Rust source code to an AST.
-full, printing | 6 sec | Turning an AST into Rust source code.
-full, parsing, printing | 11 sec | Parsing and printing any Rust syntax.
-
-## License
-
-Licensed under either of
-
- * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/generics.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-use {Generics, Ident, LifetimeDef, TyParam, WhereClause, WherePredicate};
-use aster::invoke::{Identity, Invoke};
-use aster::lifetime::{IntoLifetime, LifetimeDefBuilder, IntoLifetimeDef};
-use aster::path::IntoPath;
-use aster::ty_param::TyParamBuilder;
-use aster::where_predicate::WherePredicateBuilder;
-
-pub struct GenericsBuilder<F = Identity> {
- callback: F,
- lifetimes: Vec<LifetimeDef>,
- ty_params: Vec<TyParam>,
- predicates: Vec<WherePredicate>,
-}
-
-impl GenericsBuilder {
- pub fn new() -> Self {
- GenericsBuilder::with_callback(Identity)
- }
-
- pub fn from_generics(generics: Generics) -> Self {
- GenericsBuilder::from_generics_with_callback(generics, Identity)
- }
-}
-
-impl<F> GenericsBuilder<F>
- where F: Invoke<Generics>
-{
- pub fn with_callback(callback: F) -> Self {
- GenericsBuilder {
- callback: callback,
- lifetimes: Vec::new(),
- ty_params: Vec::new(),
- predicates: Vec::new(),
- }
- }
-
- pub fn from_generics_with_callback(generics: Generics, callback: F) -> Self {
- GenericsBuilder {
- callback: callback,
- lifetimes: generics.lifetimes,
- ty_params: generics.ty_params,
- predicates: generics.where_clause.predicates,
- }
- }
-
- pub fn with(self, generics: Generics) -> Self {
- self.with_lifetimes(generics.lifetimes.into_iter())
- .with_ty_params(generics.ty_params.into_iter())
- .with_predicates(generics.where_clause.predicates.into_iter())
- }
-
- pub fn with_lifetimes<I, L>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = L>,
- L: IntoLifetimeDef
- {
- let iter = iter.into_iter().map(|lifetime_def| lifetime_def.into_lifetime_def());
- self.lifetimes.extend(iter);
- self
- }
-
- pub fn with_lifetime_names<I, N>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = N>,
- N: Into<Ident>
- {
- for name in iter {
- self = self.lifetime_name(name);
- }
- self
- }
-
- pub fn with_lifetime(mut self, lifetime: LifetimeDef) -> Self {
- self.lifetimes.push(lifetime);
- self
- }
-
- pub fn lifetime_name<N>(self, name: N) -> Self
- where N: Into<Ident>
- {
- self.lifetime(name).build()
- }
-
- pub fn lifetime<N>(self, name: N) -> LifetimeDefBuilder<Self>
- where N: Into<Ident>
- {
- LifetimeDefBuilder::with_callback(name, self)
- }
-
- pub fn with_ty_params<I>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = TyParam>
- {
- self.ty_params.extend(iter);
- self
- }
-
- pub fn with_ty_param_ids<I, T>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = T>,
- T: Into<Ident>
- {
- for id in iter {
- self = self.ty_param_id(id);
- }
- self
- }
-
- pub fn with_ty_param(mut self, ty_param: TyParam) -> Self {
- self.ty_params.push(ty_param);
- self
- }
-
- pub fn ty_param_id<I>(self, id: I) -> Self
- where I: Into<Ident>
- {
- self.ty_param(id).build()
- }
-
- pub fn ty_param<I>(self, id: I) -> TyParamBuilder<Self>
- where I: Into<Ident>
- {
- TyParamBuilder::with_callback(id, self)
- }
-
- pub fn with_predicates<I>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = WherePredicate>
- {
- self.predicates.extend(iter);
- self
- }
-
- pub fn with_predicate(mut self, predicate: WherePredicate) -> Self {
- self.predicates.push(predicate);
- self
- }
-
- pub fn predicate(self) -> WherePredicateBuilder<Self> {
- WherePredicateBuilder::with_callback(self)
- }
-
- pub fn add_lifetime_bound<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetime
- {
- let lifetime = lifetime.into_lifetime();
-
- for lifetime_def in &mut self.lifetimes {
- lifetime_def.bounds.push(lifetime.clone());
- }
-
- for ty_param in &mut self.ty_params {
- *ty_param = TyParamBuilder::from_ty_param(ty_param.clone())
- .lifetime_bound(lifetime.clone())
- .build();
- }
-
- self
- }
-
- pub fn add_ty_param_bound<P>(mut self, path: P) -> Self
- where P: IntoPath
- {
- let path = path.into_path();
-
- for ty_param in &mut self.ty_params {
- *ty_param = TyParamBuilder::from_ty_param(ty_param.clone())
- .trait_bound(path.clone())
- .build()
- .build();
- }
-
- self
- }
-
- pub fn strip_bounds(self) -> Self {
- self.strip_lifetimes().strip_ty_params().strip_predicates()
- }
-
- pub fn strip_lifetimes(mut self) -> Self {
- for lifetime in &mut self.lifetimes {
- lifetime.bounds = vec![];
- }
- self
- }
-
- pub fn strip_ty_params(mut self) -> Self {
- for ty_param in &mut self.ty_params {
- ty_param.bounds = vec![];
- }
- self
- }
-
- pub fn strip_predicates(mut self) -> Self {
- self.predicates = vec![];
- self
- }
-
- pub fn build(self) -> F::Result {
- self.callback.invoke(Generics {
- lifetimes: self.lifetimes,
- ty_params: self.ty_params,
- where_clause: WhereClause { predicates: self.predicates },
- })
- }
-}
-
-impl<F> Invoke<LifetimeDef> for GenericsBuilder<F>
- where F: Invoke<Generics>
-{
- type Result = Self;
-
- fn invoke(self, lifetime: LifetimeDef) -> Self {
- self.with_lifetime(lifetime)
- }
-}
-
-impl<F> Invoke<TyParam> for GenericsBuilder<F>
- where F: Invoke<Generics>
-{
- type Result = Self;
-
- fn invoke(self, ty_param: TyParam) -> Self {
- self.with_ty_param(ty_param)
- }
-}
-
-impl<F> Invoke<WherePredicate> for GenericsBuilder<F>
- where F: Invoke<Generics>
-{
- type Result = Self;
-
- fn invoke(self, predicate: WherePredicate) -> Self {
- self.with_predicate(predicate)
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/ident.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use Ident;
-
-pub trait ToIdent {
- fn to_ident(&self) -> Ident;
-}
-
-impl ToIdent for Ident {
- fn to_ident(&self) -> Ident {
- self.clone()
- }
-}
-
-impl<'a> ToIdent for &'a str {
- fn to_ident(&self) -> Ident {
- (**self).into()
- }
-}
-
-impl ToIdent for String {
- fn to_ident(&self) -> Ident {
- self.clone().into()
- }
-}
-
-impl<'a, T> ToIdent for &'a T
- where T: ToIdent
-{
- fn to_ident(&self) -> Ident {
- (**self).to_ident()
- }
-}
-
-impl<'a, T> ToIdent for &'a mut T
- where T: ToIdent
-{
- fn to_ident(&self) -> Ident {
- (**self).to_ident()
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/invoke.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-pub trait Invoke<A> {
- type Result;
-
- fn invoke(self, arg: A) -> Self::Result;
-}
-
-#[derive(Copy, Clone)]
-pub struct Identity;
-
-impl<A> Invoke<A> for Identity {
- type Result = A;
-
- fn invoke(self, arg: A) -> A {
- arg
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/lifetime.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use {Ident, Lifetime, LifetimeDef};
-use aster::invoke::{Invoke, Identity};
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub trait IntoLifetime {
- fn into_lifetime(self) -> Lifetime;
-}
-
-impl IntoLifetime for Lifetime {
- fn into_lifetime(self) -> Lifetime {
- self
- }
-}
-
-impl<'a> IntoLifetime for &'a str {
- fn into_lifetime(self) -> Lifetime {
- Lifetime { ident: self.into() }
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub trait IntoLifetimeDef {
- fn into_lifetime_def(self) -> LifetimeDef;
-}
-
-impl IntoLifetimeDef for LifetimeDef {
- fn into_lifetime_def(self) -> LifetimeDef {
- self
- }
-}
-
-impl IntoLifetimeDef for Lifetime {
- fn into_lifetime_def(self) -> LifetimeDef {
- LifetimeDef {
- attrs: vec![],
- lifetime: self,
- bounds: vec![],
- }
- }
-}
-
-impl<'a> IntoLifetimeDef for &'a str {
- fn into_lifetime_def(self) -> LifetimeDef {
- self.into_lifetime().into_lifetime_def()
- }
-}
-
-impl IntoLifetimeDef for String {
- fn into_lifetime_def(self) -> LifetimeDef {
- (*self).into_lifetime().into_lifetime_def()
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct LifetimeDefBuilder<F = Identity> {
- callback: F,
- lifetime: Lifetime,
- bounds: Vec<Lifetime>,
-}
-
-impl LifetimeDefBuilder {
- pub fn new<N>(name: N) -> Self
- where N: Into<Ident>
- {
- LifetimeDefBuilder::with_callback(name, Identity)
- }
-}
-
-impl<F> LifetimeDefBuilder<F>
- where F: Invoke<LifetimeDef>
-{
- pub fn with_callback<N>(name: N, callback: F) -> Self
- where N: Into<Ident>
- {
- let lifetime = Lifetime { ident: name.into() };
-
- LifetimeDefBuilder {
- callback: callback,
- lifetime: lifetime,
- bounds: Vec::new(),
- }
- }
-
- pub fn bound<N>(mut self, name: N) -> Self
- where N: Into<Ident>
- {
- let lifetime = Lifetime { ident: name.into() };
-
- self.bounds.push(lifetime);
- self
- }
-
- pub fn build(self) -> F::Result {
- self.callback.invoke(LifetimeDef {
- attrs: vec![],
- lifetime: self.lifetime,
- bounds: self.bounds,
- })
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/mod.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use super::*;
-
-pub mod generics;
-pub mod ident;
-pub mod invoke;
-pub mod lifetime;
-pub mod path;
-pub mod qpath;
-pub mod ty;
-pub mod ty_param;
-pub mod where_predicate;
-
-pub fn id<I>(id: I) -> Ident
- where I: Into<Ident>
-{
- id.into()
-}
-
-pub fn from_generics(generics: Generics) -> generics::GenericsBuilder {
- generics::GenericsBuilder::from_generics(generics)
-}
-
-pub fn where_predicate() -> where_predicate::WherePredicateBuilder {
- where_predicate::WherePredicateBuilder::new()
-}
-
-pub fn ty() -> ty::TyBuilder {
- ty::TyBuilder::new()
-}
-
-pub fn path() -> path::PathBuilder {
- path::PathBuilder::new()
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/path.rs
+++ /dev/null
@@ -1,327 +0,0 @@
-use {AngleBracketedParameterData, Generics, Ident, Lifetime, ParenthesizedParameterData, Path,
- PathParameters, PathSegment, Ty, TypeBinding};
-use aster::ident::ToIdent;
-use aster::invoke::{Invoke, Identity};
-use aster::lifetime::IntoLifetime;
-use aster::ty::TyBuilder;
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub trait IntoPath {
- fn into_path(self) -> Path;
-}
-
-impl IntoPath for Path {
- fn into_path(self) -> Path {
- self
- }
-}
-
-impl IntoPath for Ident {
- fn into_path(self) -> Path {
- PathBuilder::new().id(self).build()
- }
-}
-
-impl<'a> IntoPath for &'a str {
- fn into_path(self) -> Path {
- PathBuilder::new().id(self).build()
- }
-}
-
-impl IntoPath for String {
- fn into_path(self) -> Path {
- (&*self).into_path()
- }
-}
-
-impl<'a, T> IntoPath for &'a [T]
- where T: ToIdent
-{
- fn into_path(self) -> Path {
- PathBuilder::new().ids(self).build()
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct PathBuilder<F = Identity> {
- callback: F,
- global: bool,
-}
-
-impl PathBuilder {
- pub fn new() -> Self {
- PathBuilder::with_callback(Identity)
- }
-}
-
-impl<F> PathBuilder<F>
- where F: Invoke<Path>
-{
- pub fn with_callback(callback: F) -> Self {
- PathBuilder {
- callback: callback,
- global: false,
- }
- }
-
- pub fn build(self, path: Path) -> F::Result {
- self.callback.invoke(path)
- }
-
- pub fn global(mut self) -> Self {
- self.global = true;
- self
- }
-
- pub fn ids<I, T>(self, ids: I) -> PathSegmentsBuilder<F>
- where I: IntoIterator<Item = T>,
- T: ToIdent
- {
- let mut ids = ids.into_iter();
- let id = ids.next().expect("passed path with no id");
-
- self.id(id).ids(ids)
- }
-
- pub fn id<I>(self, id: I) -> PathSegmentsBuilder<F>
- where I: ToIdent
- {
- self.segment(id).build()
- }
-
- pub fn segment<I>(self, id: I) -> PathSegmentBuilder<PathSegmentsBuilder<F>>
- where I: ToIdent
- {
- PathSegmentBuilder::with_callback(id,
- PathSegmentsBuilder {
- callback: self.callback,
- global: self.global,
- segments: Vec::new(),
- })
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct PathSegmentsBuilder<F = Identity> {
- callback: F,
- global: bool,
- segments: Vec<PathSegment>,
-}
-
-impl<F> PathSegmentsBuilder<F>
- where F: Invoke<Path>
-{
- pub fn ids<I, T>(mut self, ids: I) -> PathSegmentsBuilder<F>
- where I: IntoIterator<Item = T>,
- T: ToIdent
- {
- for id in ids {
- self = self.id(id);
- }
-
- self
- }
-
- pub fn id<T>(self, id: T) -> PathSegmentsBuilder<F>
- where T: ToIdent
- {
- self.segment(id).build()
- }
-
- pub fn segment<T>(self, id: T) -> PathSegmentBuilder<Self>
- where T: ToIdent
- {
- PathSegmentBuilder::with_callback(id, self)
- }
-
- pub fn build(self) -> F::Result {
- self.callback.invoke(Path {
- global: self.global,
- segments: self.segments,
- })
- }
-}
-
-impl<F> Invoke<PathSegment> for PathSegmentsBuilder<F> {
- type Result = Self;
-
- fn invoke(mut self, segment: PathSegment) -> Self {
- self.segments.push(segment);
- self
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct PathSegmentBuilder<F = Identity> {
- callback: F,
- id: Ident,
- lifetimes: Vec<Lifetime>,
- tys: Vec<Ty>,
- bindings: Vec<TypeBinding>,
-}
-
-impl<F> PathSegmentBuilder<F>
- where F: Invoke<PathSegment>
-{
- pub fn with_callback<I>(id: I, callback: F) -> Self
- where I: ToIdent
- {
- PathSegmentBuilder {
- callback: callback,
- id: id.to_ident(),
- lifetimes: Vec::new(),
- tys: Vec::new(),
- bindings: Vec::new(),
- }
- }
-
- pub fn with_generics(self, generics: Generics) -> Self {
- // Strip off the bounds.
- let lifetimes = generics.lifetimes.iter().map(|lifetime_def| lifetime_def.lifetime.clone());
-
- let tys =
- generics.ty_params.iter().map(|ty_param| TyBuilder::new().id(ty_param.ident.clone()));
-
- self.with_lifetimes(lifetimes).with_tys(tys)
- }
-
- pub fn with_lifetimes<I, L>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = L>,
- L: IntoLifetime
- {
- let iter = iter.into_iter().map(|lifetime| lifetime.into_lifetime());
- self.lifetimes.extend(iter);
- self
- }
-
- pub fn with_lifetime<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetime
- {
- self.lifetimes.push(lifetime.into_lifetime());
- self
- }
-
- pub fn lifetime<N>(self, name: N) -> Self
- where N: ToIdent
- {
- let lifetime = Lifetime { ident: name.to_ident() };
- self.with_lifetime(lifetime)
- }
-
- pub fn with_tys<I>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = Ty>
- {
- self.tys.extend(iter);
- self
- }
-
- pub fn with_ty(mut self, ty: Ty) -> Self {
- self.tys.push(ty);
- self
- }
-
- pub fn ty(self) -> TyBuilder<Self> {
- TyBuilder::with_callback(self)
- }
-
- pub fn with_binding(mut self, binding: TypeBinding) -> Self {
- self.bindings.push(binding);
- self
- }
-
- pub fn binding<T>(self, id: T) -> TyBuilder<TypeBindingBuilder<F>>
- where T: ToIdent
- {
- TyBuilder::with_callback(TypeBindingBuilder {
- id: id.to_ident(),
- builder: self,
- })
- }
-
- pub fn no_return(self) -> F::Result {
- self.build_return(None)
- }
-
- pub fn return_(self) -> TyBuilder<PathSegmentReturnBuilder<F>> {
- TyBuilder::with_callback(PathSegmentReturnBuilder(self))
- }
-
- pub fn build_return(self, output: Option<Ty>) -> F::Result {
- let data = ParenthesizedParameterData {
- inputs: self.tys,
- output: output,
- };
-
- let parameters = PathParameters::Parenthesized(data);
-
- self.callback.invoke(PathSegment {
- ident: self.id,
- parameters: parameters,
- })
- }
-
- pub fn build(self) -> F::Result {
- let data = AngleBracketedParameterData {
- lifetimes: self.lifetimes,
- types: self.tys,
- bindings: self.bindings,
- };
-
- let parameters = PathParameters::AngleBracketed(data);
-
- self.callback.invoke(PathSegment {
- ident: self.id,
- parameters: parameters,
- })
- }
-}
-
-impl<F> Invoke<Ty> for PathSegmentBuilder<F>
- where F: Invoke<PathSegment>
-{
- type Result = Self;
-
- fn invoke(self, ty: Ty) -> Self {
- self.with_ty(ty)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TypeBindingBuilder<F> {
- id: Ident,
- builder: PathSegmentBuilder<F>,
-}
-
-impl<F> Invoke<Ty> for TypeBindingBuilder<F>
- where F: Invoke<PathSegment>
-{
- type Result = PathSegmentBuilder<F>;
-
- fn invoke(self, ty: Ty) -> Self::Result {
- let id = self.id;
-
- self.builder.with_binding(TypeBinding {
- ident: id,
- ty: ty,
- })
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct PathSegmentReturnBuilder<F>(PathSegmentBuilder<F>);
-
-impl<F> Invoke<Ty> for PathSegmentReturnBuilder<F>
- where F: Invoke<PathSegment>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> Self::Result {
- self.0.build_return(Some(ty))
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/qpath.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-use {Path, PathSegment, QSelf, Ty};
-use aster::ident::ToIdent;
-use aster::invoke::{Invoke, Identity};
-use aster::path::{PathBuilder, PathSegmentBuilder};
-use aster::ty::TyBuilder;
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct QPathBuilder<F = Identity> {
- callback: F,
-}
-
-impl QPathBuilder {
- pub fn new() -> Self {
- QPathBuilder::with_callback(Identity)
- }
-}
-
-impl<F> QPathBuilder<F>
- where F: Invoke<(QSelf, Path)>
-{
- /// Construct a `QPathBuilder` that will call the `callback` with a constructed `QSelf`
- /// and `Path`.
- pub fn with_callback(callback: F) -> Self {
- QPathBuilder { callback: callback }
- }
-
- /// Build a qualified path first by starting with a type builder.
- pub fn with_ty(self, ty: Ty) -> QPathTyBuilder<F> {
- QPathTyBuilder {
- builder: self,
- ty: ty,
- }
- }
-
- /// Build a qualified path first by starting with a type builder.
- pub fn ty(self) -> TyBuilder<Self> {
- TyBuilder::with_callback(self)
- }
-
- /// Build a qualified path with a concrete type and path.
- pub fn build(self, qself: QSelf, path: Path) -> F::Result {
- self.callback.invoke((qself, path))
- }
-}
-
-impl<F> Invoke<Ty> for QPathBuilder<F>
- where F: Invoke<(QSelf, Path)>
-{
- type Result = QPathTyBuilder<F>;
-
- fn invoke(self, ty: Ty) -> QPathTyBuilder<F> {
- self.with_ty(ty)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct QPathTyBuilder<F> {
- builder: QPathBuilder<F>,
- ty: Ty,
-}
-
-impl<F> QPathTyBuilder<F>
- where F: Invoke<(QSelf, Path)>
-{
- /// Build a qualified path with a path builder.
- pub fn as_(self) -> PathBuilder<Self> {
- PathBuilder::with_callback(self)
- }
-
- pub fn id<T>(self, id: T) -> F::Result
- where T: ToIdent
- {
- let path = Path {
- global: false,
- segments: vec![],
- };
- self.as_().build(path).id(id)
- }
-
- pub fn segment<T>(self, id: T) -> PathSegmentBuilder<QPathQSelfBuilder<F>>
- where T: ToIdent
- {
- let path = Path {
- global: false,
- segments: vec![],
- };
- self.as_().build(path).segment(id)
- }
-}
-
-impl<F> Invoke<Path> for QPathTyBuilder<F>
- where F: Invoke<(QSelf, Path)>
-{
- type Result = QPathQSelfBuilder<F>;
-
- fn invoke(self, path: Path) -> QPathQSelfBuilder<F> {
- QPathQSelfBuilder {
- builder: self.builder,
- qself: QSelf {
- ty: Box::new(self.ty),
- position: path.segments.len(),
- },
- path: path,
- }
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct QPathQSelfBuilder<F> {
- builder: QPathBuilder<F>,
- qself: QSelf,
- path: Path,
-}
-
-impl<F> QPathQSelfBuilder<F>
- where F: Invoke<(QSelf, Path)>
-{
- pub fn id<T>(self, id: T) -> F::Result
- where T: ToIdent
- {
- self.segment(id).build()
- }
-
- pub fn segment<T>(self, id: T) -> PathSegmentBuilder<QPathQSelfBuilder<F>>
- where T: ToIdent
- {
- PathSegmentBuilder::with_callback(id, self)
- }
-}
-
-impl<F> Invoke<PathSegment> for QPathQSelfBuilder<F>
- where F: Invoke<(QSelf, Path)>
-{
- type Result = F::Result;
-
- fn invoke(mut self, segment: PathSegment) -> F::Result {
- self.path.segments.push(segment);
- self.builder.build(self.qself, self.path)
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/ty.rs
+++ /dev/null
@@ -1,488 +0,0 @@
-use {Generics, Lifetime, MutTy, Mutability, Path, QSelf, Ty, TyParamBound};
-use aster::ident::ToIdent;
-use aster::invoke::{Invoke, Identity};
-use aster::lifetime::IntoLifetime;
-use aster::path::PathBuilder;
-use aster::qpath::QPathBuilder;
-use aster::ty_param::TyParamBoundBuilder;
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyBuilder<F = Identity> {
- callback: F,
-}
-
-impl TyBuilder {
- pub fn new() -> Self {
- TyBuilder::with_callback(Identity)
- }
-}
-
-impl<F> TyBuilder<F>
- where F: Invoke<Ty>
-{
- pub fn with_callback(callback: F) -> Self {
- TyBuilder { callback: callback }
- }
-
- pub fn build(self, ty: Ty) -> F::Result {
- self.callback.invoke(ty)
- }
-
- pub fn id<I>(self, id: I) -> F::Result
- where I: ToIdent
- {
- self.path().id(id).build()
- }
-
- pub fn build_path(self, path: Path) -> F::Result {
- self.build(Ty::Path(None, path))
- }
-
- pub fn build_qpath(self, qself: QSelf, path: Path) -> F::Result {
- self.build(Ty::Path(Some(qself), path))
- }
-
- pub fn path(self) -> PathBuilder<TyPathBuilder<F>> {
- PathBuilder::with_callback(TyPathBuilder(self))
- }
-
- pub fn qpath(self) -> QPathBuilder<TyQPathBuilder<F>> {
- QPathBuilder::with_callback(TyQPathBuilder(self))
- }
-
- pub fn isize(self) -> F::Result {
- self.id("isize")
- }
-
- pub fn i8(self) -> F::Result {
- self.id("i8")
- }
-
- pub fn i16(self) -> F::Result {
- self.id("i16")
- }
-
- pub fn i32(self) -> F::Result {
- self.id("i32")
- }
-
- pub fn i64(self) -> F::Result {
- self.id("i64")
- }
-
- pub fn usize(self) -> F::Result {
- self.id("usize")
- }
-
- pub fn u8(self) -> F::Result {
- self.id("u8")
- }
-
- pub fn u16(self) -> F::Result {
- self.id("u16")
- }
-
- pub fn u32(self) -> F::Result {
- self.id("u32")
- }
-
- pub fn u64(self) -> F::Result {
- self.id("u64")
- }
-
- pub fn f32(self) -> F::Result {
- self.id("f32")
- }
-
- pub fn f64(self) -> F::Result {
- self.id("f64")
- }
-
- pub fn bool(self) -> F::Result {
- self.id("bool")
- }
-
- pub fn unit(self) -> F::Result {
- self.tuple().build()
- }
-
- pub fn tuple(self) -> TyTupleBuilder<F> {
- TyTupleBuilder {
- builder: self,
- tys: vec![],
- }
- }
-
- pub fn build_slice(self, ty: Ty) -> F::Result {
- self.build(Ty::Slice(Box::new(ty)))
- }
-
- pub fn slice(self) -> TyBuilder<TySliceBuilder<F>> {
- TyBuilder::with_callback(TySliceBuilder(self))
- }
-
- pub fn ref_(self) -> TyRefBuilder<F> {
- TyRefBuilder {
- builder: self,
- lifetime: None,
- mutability: Mutability::Immutable,
- }
- }
-
- pub fn never(self) -> F::Result {
- self.build(Ty::Never)
- }
-
- pub fn infer(self) -> F::Result {
- self.build(Ty::Infer)
- }
-
- pub fn option(self) -> TyBuilder<TyOptionBuilder<F>> {
- TyBuilder::with_callback(TyOptionBuilder(self))
- }
-
- pub fn result(self) -> TyBuilder<TyResultOkBuilder<F>> {
- TyBuilder::with_callback(TyResultOkBuilder(self))
- }
-
- pub fn phantom_data(self) -> TyBuilder<TyPhantomDataBuilder<F>> {
- TyBuilder::with_callback(TyPhantomDataBuilder(self))
- }
-
- pub fn box_(self) -> TyBuilder<TyBoxBuilder<F>> {
- TyBuilder::with_callback(TyBoxBuilder(self))
- }
-
- pub fn iterator(self) -> TyBuilder<TyIteratorBuilder<F>> {
- TyBuilder::with_callback(TyIteratorBuilder(self))
- }
-
- pub fn impl_trait(self) -> TyImplTraitTyBuilder<F> {
- TyImplTraitTyBuilder {
- builder: self,
- bounds: Vec::new(),
- }
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyPathBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Path> for TyPathBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, path: Path) -> F::Result {
- self.0.build_path(path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyQPathBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<(QSelf, Path)> for TyQPathBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, (qself, path): (QSelf, Path)) -> F::Result {
- self.0.build_qpath(qself, path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TySliceBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Ty> for TySliceBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- self.0.build_slice(ty)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyRefBuilder<F> {
- builder: TyBuilder<F>,
- lifetime: Option<Lifetime>,
- mutability: Mutability,
-}
-
-impl<F> TyRefBuilder<F>
- where F: Invoke<Ty>
-{
- pub fn mut_(mut self) -> Self {
- self.mutability = Mutability::Mutable;
- self
- }
-
- pub fn lifetime<N>(mut self, name: N) -> Self
- where N: ToIdent
- {
- self.lifetime = Some(Lifetime { ident: name.to_ident() });
- self
- }
-
- pub fn build_ty(self, ty: Ty) -> F::Result {
- let ty = MutTy {
- ty: ty,
- mutability: self.mutability,
- };
- self.builder.build(Ty::Rptr(self.lifetime, Box::new(ty)))
- }
-
- pub fn ty(self) -> TyBuilder<Self> {
- TyBuilder::with_callback(self)
- }
-}
-
-impl<F> Invoke<Ty> for TyRefBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- self.build_ty(ty)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyOptionBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Ty> for TyOptionBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- let path = PathBuilder::new()
- .global()
- .id("std")
- .id("option")
- .segment("Option")
- .with_ty(ty)
- .build()
- .build();
-
- self.0.build_path(path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyResultOkBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Ty> for TyResultOkBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = TyBuilder<TyResultErrBuilder<F>>;
-
- fn invoke(self, ty: Ty) -> TyBuilder<TyResultErrBuilder<F>> {
- TyBuilder::with_callback(TyResultErrBuilder(self.0, ty))
- }
-}
-
-pub struct TyResultErrBuilder<F>(TyBuilder<F>, Ty);
-
-impl<F> Invoke<Ty> for TyResultErrBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- let path = PathBuilder::new()
- .global()
- .id("std")
- .id("result")
- .segment("Result")
- .with_ty(self.1)
- .with_ty(ty)
- .build()
- .build();
-
- self.0.build_path(path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyPhantomDataBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Ty> for TyPhantomDataBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- let path = PathBuilder::new()
- .global()
- .id("std")
- .id("marker")
- .segment("PhantomData")
- .with_ty(ty)
- .build()
- .build();
-
- self.0.build_path(path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyBoxBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Ty> for TyBoxBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- let path = PathBuilder::new()
- .global()
- .id("std")
- .id("boxed")
- .segment("Box")
- .with_ty(ty)
- .build()
- .build();
-
- self.0.build_path(path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyIteratorBuilder<F>(TyBuilder<F>);
-
-impl<F> Invoke<Ty> for TyIteratorBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = F::Result;
-
- fn invoke(self, ty: Ty) -> F::Result {
- let path = PathBuilder::new()
- .global()
- .id("std")
- .id("iter")
- .segment("Iterator")
- .binding("Item")
- .build(ty.clone())
- .build()
- .build();
-
- self.0.build_path(path)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyImplTraitTyBuilder<F> {
- builder: TyBuilder<F>,
- bounds: Vec<TyParamBound>,
-}
-
-impl<F> TyImplTraitTyBuilder<F>
- where F: Invoke<Ty>
-{
- pub fn with_bounds<I>(mut self, iter: I) -> Self
- where I: Iterator<Item = TyParamBound>
- {
- self.bounds.extend(iter);
- self
- }
-
- pub fn with_bound(mut self, bound: TyParamBound) -> Self {
- self.bounds.push(bound);
- self
- }
-
- pub fn bound(self) -> TyParamBoundBuilder<Self> {
- TyParamBoundBuilder::with_callback(self)
- }
-
- pub fn with_generics(self, generics: Generics) -> Self {
- self.with_lifetimes(generics.lifetimes.into_iter().map(|def| def.lifetime))
- }
-
- pub fn with_lifetimes<I, L>(mut self, lifetimes: I) -> Self
- where I: Iterator<Item = L>,
- L: IntoLifetime
- {
- for lifetime in lifetimes {
- self = self.lifetime(lifetime);
- }
-
- self
- }
-
- pub fn lifetime<L>(self, lifetime: L) -> Self
- where L: IntoLifetime
- {
- self.bound().lifetime(lifetime)
- }
-
- pub fn build(self) -> F::Result {
- let bounds = self.bounds;
- self.builder.build(Ty::ImplTrait(bounds))
- }
-}
-
-impl<F> Invoke<TyParamBound> for TyImplTraitTyBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = Self;
-
- fn invoke(self, bound: TyParamBound) -> Self {
- self.with_bound(bound)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyTupleBuilder<F> {
- builder: TyBuilder<F>,
- tys: Vec<Ty>,
-}
-
-impl<F> TyTupleBuilder<F>
- where F: Invoke<Ty>
-{
- pub fn with_tys<I>(mut self, iter: I) -> Self
- where I: IntoIterator<Item = Ty>
- {
- self.tys.extend(iter);
- self
- }
-
- pub fn with_ty(mut self, ty: Ty) -> Self {
- self.tys.push(ty);
- self
- }
-
- pub fn ty(self) -> TyBuilder<Self> {
- TyBuilder::with_callback(self)
- }
-
- pub fn build(self) -> F::Result {
- self.builder.build(Ty::Tup(self.tys))
- }
-}
-
-impl<F> Invoke<Ty> for TyTupleBuilder<F>
- where F: Invoke<Ty>
-{
- type Result = Self;
-
- fn invoke(self, ty: Ty) -> Self {
- self.with_ty(ty)
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/ty_param.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-use {Ident, LifetimeDef, Path, PolyTraitRef, TraitBoundModifier, Ty, TyParam, TyParamBound};
-use aster::invoke::{Invoke, Identity};
-use aster::lifetime::{IntoLifetime, IntoLifetimeDef, LifetimeDefBuilder};
-use aster::path::{IntoPath, PathBuilder};
-use aster::ty::TyBuilder;
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyParamBuilder<F = Identity> {
- callback: F,
- id: Ident,
- bounds: Vec<TyParamBound>,
- default: Option<Ty>,
-}
-
-impl TyParamBuilder {
- pub fn new<I>(id: I) -> Self
- where I: Into<Ident>
- {
- TyParamBuilder::with_callback(id, Identity)
- }
-
- pub fn from_ty_param(ty_param: TyParam) -> Self {
- TyParamBuilder::from_ty_param_with_callback(Identity, ty_param)
- }
-}
-
-impl<F> TyParamBuilder<F>
- where F: Invoke<TyParam>
-{
- pub fn with_callback<I>(id: I, callback: F) -> Self
- where I: Into<Ident>
- {
- TyParamBuilder {
- callback: callback,
- id: id.into(),
- bounds: Vec::new(),
- default: None,
- }
- }
-
- pub fn from_ty_param_with_callback(callback: F, ty_param: TyParam) -> Self {
- TyParamBuilder {
- callback: callback,
- id: ty_param.ident,
- bounds: ty_param.bounds,
- default: ty_param.default,
- }
- }
-
- pub fn with_default(mut self, ty: Ty) -> Self {
- self.default = Some(ty);
- self
- }
-
- pub fn default(self) -> TyBuilder<Self> {
- TyBuilder::with_callback(self)
- }
-
- pub fn with_bound(mut self, bound: TyParamBound) -> Self {
- self.bounds.push(bound);
- self
- }
-
- pub fn bound(self) -> TyParamBoundBuilder<Self> {
- TyParamBoundBuilder::with_callback(self)
- }
-
- pub fn with_trait_bound(self, trait_ref: PolyTraitRef) -> Self {
- self.bound().build_trait(trait_ref, TraitBoundModifier::None)
- }
-
- pub fn trait_bound<P>(self, path: P) -> PolyTraitRefBuilder<Self>
- where P: IntoPath
- {
- PolyTraitRefBuilder::with_callback(path, self)
- }
-
- pub fn lifetime_bound<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetime
- {
- let lifetime = lifetime.into_lifetime();
-
- self.bounds.push(TyParamBound::Region(lifetime));
- self
- }
-
- pub fn build(self) -> F::Result {
- self.callback.invoke(TyParam {
- attrs: vec![],
- ident: self.id,
- bounds: self.bounds,
- default: self.default,
- })
- }
-}
-
-impl<F> Invoke<Ty> for TyParamBuilder<F>
- where F: Invoke<TyParam>
-{
- type Result = Self;
-
- fn invoke(self, ty: Ty) -> Self {
- self.with_default(ty)
- }
-}
-
-impl<F> Invoke<TyParamBound> for TyParamBuilder<F>
- where F: Invoke<TyParam>
-{
- type Result = Self;
-
- fn invoke(self, bound: TyParamBound) -> Self {
- self.with_bound(bound)
- }
-}
-
-impl<F> Invoke<PolyTraitRef> for TyParamBuilder<F>
- where F: Invoke<TyParam>
-{
- type Result = Self;
-
- fn invoke(self, trait_ref: PolyTraitRef) -> Self {
- self.with_trait_bound(trait_ref)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TyParamBoundBuilder<F = Identity> {
- callback: F,
-}
-
-impl TyParamBoundBuilder {
- pub fn new() -> Self {
- TyParamBoundBuilder::with_callback(Identity)
- }
-}
-
-impl<F> TyParamBoundBuilder<F>
- where F: Invoke<TyParamBound>
-{
- pub fn with_callback(callback: F) -> Self {
- TyParamBoundBuilder { callback: callback }
- }
-
- pub fn build_trait(self, poly_trait: PolyTraitRef, modifier: TraitBoundModifier) -> F::Result {
- let bound = TyParamBound::Trait(poly_trait, modifier);
- self.callback.invoke(bound)
- }
-
- pub fn trait_<P>(self, path: P) -> PolyTraitRefBuilder<TraitTyParamBoundBuilder<F>>
- where P: IntoPath
- {
- let builder = TraitTyParamBoundBuilder {
- builder: self,
- modifier: TraitBoundModifier::None,
- };
-
- PolyTraitRefBuilder::with_callback(path, builder)
- }
-
- pub fn maybe_trait<P>(self, path: P) -> PolyTraitRefBuilder<TraitTyParamBoundBuilder<F>>
- where P: IntoPath
- {
- let builder = TraitTyParamBoundBuilder {
- builder: self,
- modifier: TraitBoundModifier::Maybe,
- };
-
- PolyTraitRefBuilder::with_callback(path, builder)
- }
-
- pub fn iterator(self, ty: Ty) -> PolyTraitRefBuilder<TraitTyParamBoundBuilder<F>> {
- let path = PathBuilder::new()
- .global()
- .id("std")
- .id("iter")
- .segment("Iterator")
- .binding("Item")
- .build(ty)
- .build()
- .build();
- self.trait_(path)
- }
-
- pub fn lifetime<L>(self, lifetime: L) -> F::Result
- where L: IntoLifetime
- {
- let lifetime = lifetime.into_lifetime();
- self.callback.invoke(TyParamBound::Region(lifetime))
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct TraitTyParamBoundBuilder<F> {
- builder: TyParamBoundBuilder<F>,
- modifier: TraitBoundModifier,
-}
-
-impl<F> Invoke<PolyTraitRef> for TraitTyParamBoundBuilder<F>
- where F: Invoke<TyParamBound>
-{
- type Result = F::Result;
-
- fn invoke(self, poly_trait: PolyTraitRef) -> Self::Result {
- self.builder.build_trait(poly_trait, self.modifier)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct PolyTraitRefBuilder<F> {
- callback: F,
- trait_ref: Path,
- lifetimes: Vec<LifetimeDef>,
-}
-
-impl<F> PolyTraitRefBuilder<F>
- where F: Invoke<PolyTraitRef>
-{
- pub fn with_callback<P>(path: P, callback: F) -> Self
- where P: IntoPath
- {
- PolyTraitRefBuilder {
- callback: callback,
- trait_ref: path.into_path(),
- lifetimes: Vec::new(),
- }
- }
-
- pub fn with_lifetime<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetimeDef
- {
- self.lifetimes.push(lifetime.into_lifetime_def());
- self
- }
-
- pub fn lifetime<N>(self, name: N) -> LifetimeDefBuilder<Self>
- where N: Into<Ident>
- {
- LifetimeDefBuilder::with_callback(name, self)
- }
-
- pub fn build(self) -> F::Result {
- self.callback.invoke(PolyTraitRef {
- bound_lifetimes: self.lifetimes,
- trait_ref: self.trait_ref,
- })
- }
-}
-
-impl<F> Invoke<LifetimeDef> for PolyTraitRefBuilder<F>
- where F: Invoke<PolyTraitRef>
-{
- type Result = Self;
-
- fn invoke(self, lifetime: LifetimeDef) -> Self {
- self.with_lifetime(lifetime)
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/aster/where_predicate.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-use {Ident, Lifetime, LifetimeDef, Ty, TyParamBound, WhereBoundPredicate, WherePredicate,
- WhereRegionPredicate};
-use aster::invoke::{Invoke, Identity};
-use aster::lifetime::{IntoLifetime, IntoLifetimeDef, LifetimeDefBuilder};
-use aster::path::IntoPath;
-use aster::ty::TyBuilder;
-use aster::ty_param::{TyParamBoundBuilder, PolyTraitRefBuilder, TraitTyParamBoundBuilder};
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct WherePredicateBuilder<F = Identity> {
- callback: F,
-}
-
-impl WherePredicateBuilder {
- pub fn new() -> Self {
- WherePredicateBuilder::with_callback(Identity)
- }
-}
-
-impl<F> WherePredicateBuilder<F>
- where F: Invoke<WherePredicate>
-{
- pub fn with_callback(callback: F) -> Self {
- WherePredicateBuilder { callback: callback }
- }
-
- pub fn bound(self) -> TyBuilder<Self> {
- TyBuilder::with_callback(self)
- }
-
- pub fn lifetime<L>(self, lifetime: L) -> WhereRegionPredicateBuilder<F>
- where L: IntoLifetime
- {
- WhereRegionPredicateBuilder {
- callback: self.callback,
- lifetime: lifetime.into_lifetime(),
- bounds: Vec::new(),
- }
- }
-}
-
-impl<F> Invoke<Ty> for WherePredicateBuilder<F>
- where F: Invoke<WherePredicate>
-{
- type Result = WhereBoundPredicateTyBuilder<F>;
-
- fn invoke(self, ty: Ty) -> Self::Result {
- WhereBoundPredicateTyBuilder {
- callback: self.callback,
- ty: ty,
- bound_lifetimes: Vec::new(),
- }
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct WhereBoundPredicateBuilder<F> {
- callback: F,
-}
-
-impl<F> Invoke<Ty> for WhereBoundPredicateBuilder<F>
- where F: Invoke<WherePredicate>
-{
- type Result = WhereBoundPredicateTyBuilder<F>;
-
- fn invoke(self, ty: Ty) -> Self::Result {
- WhereBoundPredicateTyBuilder {
- callback: self.callback,
- ty: ty,
- bound_lifetimes: Vec::new(),
- }
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct WhereBoundPredicateTyBuilder<F> {
- callback: F,
- ty: Ty,
- bound_lifetimes: Vec<LifetimeDef>,
-}
-
-impl<F> WhereBoundPredicateTyBuilder<F>
- where F: Invoke<WherePredicate>
-{
- pub fn with_for_lifetime<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetimeDef
- {
- self.bound_lifetimes.push(lifetime.into_lifetime_def());
- self
- }
-
- pub fn for_lifetime<N>(self, name: N) -> LifetimeDefBuilder<Self>
- where N: Into<Ident>
- {
- LifetimeDefBuilder::with_callback(name, self)
- }
-
- pub fn with_bound(self, bound: TyParamBound) -> WhereBoundPredicateTyBoundsBuilder<F> {
- WhereBoundPredicateTyBoundsBuilder {
- callback: self.callback,
- ty: self.ty,
- bound_lifetimes: self.bound_lifetimes,
- bounds: vec![bound],
- }
- }
-
- pub fn bound(self) -> TyParamBoundBuilder<WhereBoundPredicateTyBoundsBuilder<F>> {
- let builder = WhereBoundPredicateTyBoundsBuilder {
- callback: self.callback,
- ty: self.ty,
- bound_lifetimes: self.bound_lifetimes,
- bounds: vec![],
- };
- TyParamBoundBuilder::with_callback(builder)
- }
-
- pub fn trait_<P>
- (self,
- path: P)
- -> PolyTraitRefBuilder<TraitTyParamBoundBuilder<WhereBoundPredicateTyBoundsBuilder<F>>>
- where P: IntoPath
- {
- self.bound().trait_(path)
- }
-
- pub fn lifetime<L>(self, lifetime: L) -> WhereBoundPredicateTyBoundsBuilder<F>
- where L: IntoLifetime
- {
- self.bound().lifetime(lifetime)
- }
-}
-
-impl<F> Invoke<LifetimeDef> for WhereBoundPredicateTyBuilder<F>
- where F: Invoke<WherePredicate>
-{
- type Result = Self;
-
- fn invoke(self, lifetime: LifetimeDef) -> Self {
- self.with_for_lifetime(lifetime)
- }
-}
-
-impl<F> Invoke<TyParamBound> for WhereBoundPredicateTyBuilder<F>
- where F: Invoke<WherePredicate>
-{
- type Result = WhereBoundPredicateTyBoundsBuilder<F>;
-
- fn invoke(self, bound: TyParamBound) -> Self::Result {
- self.with_bound(bound)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct WhereBoundPredicateTyBoundsBuilder<F> {
- callback: F,
- ty: Ty,
- bound_lifetimes: Vec<LifetimeDef>,
- bounds: Vec<TyParamBound>,
-}
-
-impl<F> WhereBoundPredicateTyBoundsBuilder<F>
- where F: Invoke<WherePredicate>
-{
- pub fn with_for_lifetime<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetimeDef
- {
- self.bound_lifetimes.push(lifetime.into_lifetime_def());
- self
- }
-
- pub fn for_lifetime<N>(self, name: N) -> LifetimeDefBuilder<Self>
- where N: Into<Ident>
- {
- LifetimeDefBuilder::with_callback(name, self)
- }
-
- pub fn with_bound(mut self, bound: TyParamBound) -> Self {
- self.bounds.push(bound);
- self
- }
-
- pub fn bound(self) -> TyParamBoundBuilder<Self> {
- TyParamBoundBuilder::with_callback(self)
- }
-
- pub fn trait_<P>(self, path: P) -> PolyTraitRefBuilder<TraitTyParamBoundBuilder<Self>>
- where P: IntoPath
- {
- self.bound().trait_(path)
- }
-
- pub fn lifetime<L>(self, lifetime: L) -> Self
- where L: IntoLifetime
- {
- self.bound().lifetime(lifetime)
- }
-
- pub fn build(self) -> F::Result {
- let predicate = WhereBoundPredicate {
- bound_lifetimes: self.bound_lifetimes,
- bounded_ty: self.ty,
- bounds: self.bounds,
- };
-
- self.callback.invoke(WherePredicate::BoundPredicate(predicate))
- }
-}
-
-impl<F> Invoke<LifetimeDef> for WhereBoundPredicateTyBoundsBuilder<F>
- where F: Invoke<WherePredicate>
-{
- type Result = Self;
-
- fn invoke(self, lifetime: LifetimeDef) -> Self {
- self.with_for_lifetime(lifetime)
- }
-}
-
-impl<F> Invoke<TyParamBound> for WhereBoundPredicateTyBoundsBuilder<F>
- where F: Invoke<WherePredicate>
-{
- type Result = Self;
-
- fn invoke(self, bound: TyParamBound) -> Self {
- self.with_bound(bound)
- }
-}
-
-// ////////////////////////////////////////////////////////////////////////////
-
-pub struct WhereRegionPredicateBuilder<F> {
- callback: F,
- lifetime: Lifetime,
- bounds: Vec<Lifetime>,
-}
-
-impl<F> WhereRegionPredicateBuilder<F>
- where F: Invoke<WherePredicate>
-{
- pub fn bound<L>(mut self, lifetime: L) -> Self
- where L: IntoLifetime
- {
- self.bounds.push(lifetime.into_lifetime());
- self
- }
-
- pub fn build(self) -> F::Result {
- let predicate = WhereRegionPredicate {
- lifetime: self.lifetime,
- bounds: self.bounds,
- };
-
- self.callback.invoke(WherePredicate::RegionPredicate(predicate))
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/attr.rs
+++ /dev/null
@@ -1,305 +0,0 @@
-use super::*;
-
-use std::iter;
-
-/// Doc-comments are promoted to attributes that have `is_sugared_doc` = true
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Attribute {
- pub style: AttrStyle,
- pub value: MetaItem,
- pub is_sugared_doc: bool,
-}
-
-impl Attribute {
- pub fn name(&self) -> &str {
- self.value.name()
- }
-}
-
-/// Distinguishes between Attributes that decorate items and Attributes that
-/// are contained as statements within items. These two cases need to be
-/// distinguished for pretty-printing.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum AttrStyle {
- /// Attribute of the form `#![...]`.
- Outer,
-
- /// Attribute of the form `#[...]`.
- Inner,
-}
-
-/// A compile-time attribute item.
-///
-/// E.g. `#[test]`, `#[derive(..)]` or `#[feature = "foo"]`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum MetaItem {
- /// Word meta item.
- ///
- /// E.g. `test` as in `#[test]`
- Word(Ident),
-
- /// List meta item.
- ///
- /// E.g. `derive(..)` as in `#[derive(..)]`
- List(Ident, Vec<NestedMetaItem>),
-
- /// Name-value meta item.
- ///
- /// E.g. `feature = "foo"` as in `#[feature = "foo"]`
- NameValue(Ident, Lit),
-}
-
-impl MetaItem {
- /// Name of the item.
- ///
- /// E.g. `test` as in `#[test]`, `derive` as in `#[derive(..)]`, and
- /// `feature` as in `#[feature = "foo"]`.
- pub fn name(&self) -> &str {
- match *self {
- MetaItem::Word(ref name) |
- MetaItem::List(ref name, _) |
- MetaItem::NameValue(ref name, _) => name.as_ref(),
- }
- }
-}
-
-/// Possible values inside of compile-time attribute lists.
-///
-/// E.g. the '..' in `#[name(..)]`.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum NestedMetaItem {
- /// A full `MetaItem`.
- ///
- /// E.g. `Copy` in `#[derive(Copy)]` would be a `MetaItem::Word(Ident::from("Copy"))`.
- MetaItem(MetaItem),
-
- /// A Rust literal.
- ///
- /// E.g. `"name"` in `#[rename("name")]`.
- Literal(Lit),
-}
-
-pub trait FilterAttrs<'a> {
- type Ret: Iterator<Item = &'a Attribute>;
-
- fn outer(self) -> Self::Ret;
- fn inner(self) -> Self::Ret;
-}
-
-impl<'a, T> FilterAttrs<'a> for T
- where T: IntoIterator<Item = &'a Attribute>
-{
- type Ret = iter::Filter<T::IntoIter, fn(&&Attribute) -> bool>;
-
- fn outer(self) -> Self::Ret {
- fn is_outer(attr: &&Attribute) -> bool {
- attr.style == AttrStyle::Outer
- }
- self.into_iter().filter(is_outer)
- }
-
- fn inner(self) -> Self::Ret {
- fn is_inner(attr: &&Attribute) -> bool {
- attr.style == AttrStyle::Inner
- }
- self.into_iter().filter(is_inner)
- }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use ident::parsing::ident;
- use lit::parsing::lit;
- use synom::space::{block_comment, whitespace};
-
- #[cfg(feature = "full")]
- named!(pub inner_attr -> Attribute, alt!(
- do_parse!(
- punct!("#") >>
- punct!("!") >>
- punct!("[") >>
- meta_item: meta_item >>
- punct!("]") >>
- (Attribute {
- style: AttrStyle::Inner,
- value: meta_item,
- is_sugared_doc: false,
- })
- )
- |
- do_parse!(
- punct!("//!") >>
- content: take_until!("\n") >>
- (Attribute {
- style: AttrStyle::Inner,
- value: MetaItem::NameValue(
- "doc".into(),
- format!("//!{}", content).into(),
- ),
- is_sugared_doc: true,
- })
- )
- |
- do_parse!(
- option!(whitespace) >>
- peek!(tag!("/*!")) >>
- com: block_comment >>
- (Attribute {
- style: AttrStyle::Inner,
- value: MetaItem::NameValue(
- "doc".into(),
- com.into(),
- ),
- is_sugared_doc: true,
- })
- )
- ));
-
- named!(pub outer_attr -> Attribute, alt!(
- do_parse!(
- punct!("#") >>
- punct!("[") >>
- meta_item: meta_item >>
- punct!("]") >>
- (Attribute {
- style: AttrStyle::Outer,
- value: meta_item,
- is_sugared_doc: false,
- })
- )
- |
- do_parse!(
- punct!("///") >>
- not!(tag!("/")) >>
- content: take_until!("\n") >>
- (Attribute {
- style: AttrStyle::Outer,
- value: MetaItem::NameValue(
- "doc".into(),
- format!("///{}", content).into(),
- ),
- is_sugared_doc: true,
- })
- )
- |
- do_parse!(
- option!(whitespace) >>
- peek!(tuple!(tag!("/**"), not!(tag!("*")))) >>
- com: block_comment >>
- (Attribute {
- style: AttrStyle::Outer,
- value: MetaItem::NameValue(
- "doc".into(),
- com.into(),
- ),
- is_sugared_doc: true,
- })
- )
- ));
-
- named!(meta_item -> MetaItem, alt!(
- do_parse!(
- id: ident >>
- punct!("(") >>
- inner: terminated_list!(punct!(","), nested_meta_item) >>
- punct!(")") >>
- (MetaItem::List(id, inner))
- )
- |
- do_parse!(
- name: ident >>
- punct!("=") >>
- value: lit >>
- (MetaItem::NameValue(name, value))
- )
- |
- map!(ident, MetaItem::Word)
- ));
-
- named!(nested_meta_item -> NestedMetaItem, alt!(
- meta_item => { NestedMetaItem::MetaItem }
- |
- lit => { NestedMetaItem::Literal }
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use lit::{Lit, StrStyle};
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Attribute {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if let Attribute { style,
- value: MetaItem::NameValue(ref name,
- Lit::Str(ref value, StrStyle::Cooked)),
- is_sugared_doc: true } = *self {
- if name == "doc" {
- match style {
- AttrStyle::Inner if value.starts_with("//!") => {
- tokens.append(&format!("{}\n", value));
- return;
- }
- AttrStyle::Inner if value.starts_with("/*!") => {
- tokens.append(value);
- return;
- }
- AttrStyle::Outer if value.starts_with("///") => {
- tokens.append(&format!("{}\n", value));
- return;
- }
- AttrStyle::Outer if value.starts_with("/**") => {
- tokens.append(value);
- return;
- }
- _ => {}
- }
- }
- }
-
- tokens.append("#");
- if let AttrStyle::Inner = self.style {
- tokens.append("!");
- }
- tokens.append("[");
- self.value.to_tokens(tokens);
- tokens.append("]");
- }
- }
-
- impl ToTokens for MetaItem {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- MetaItem::Word(ref ident) => {
- ident.to_tokens(tokens);
- }
- MetaItem::List(ref ident, ref inner) => {
- ident.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(inner, ",");
- tokens.append(")");
- }
- MetaItem::NameValue(ref name, ref value) => {
- name.to_tokens(tokens);
- tokens.append("=");
- value.to_tokens(tokens);
- }
- }
- }
- }
-
- impl ToTokens for NestedMetaItem {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- NestedMetaItem::MetaItem(ref nested) => {
- nested.to_tokens(tokens);
- }
- NestedMetaItem::Literal(ref lit) => {
- lit.to_tokens(tokens);
- }
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/constant.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-use super::*;
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ConstExpr {
- /// A function call
- ///
- /// The first field resolves to the function itself,
- /// and the second field is the list of arguments
- Call(Box<ConstExpr>, Vec<ConstExpr>),
-
- /// A binary operation (For example: `a + b`, `a * b`)
- Binary(BinOp, Box<ConstExpr>, Box<ConstExpr>),
-
- /// A unary operation (For example: `!x`, `*x`)
- Unary(UnOp, Box<ConstExpr>),
-
- /// A literal (For example: `1`, `"foo"`)
- Lit(Lit),
-
- /// A cast (`foo as f64`)
- Cast(Box<ConstExpr>, Box<Ty>),
-
- /// Variable reference, possibly containing `::` and/or type
- /// parameters, e.g. foo::bar::<baz>.
- Path(Path),
-
- /// An indexing operation (`foo[2]`)
- Index(Box<ConstExpr>, Box<ConstExpr>),
-
- /// No-op: used solely so we can pretty-print faithfully
- Paren(Box<ConstExpr>),
-
- /// If compiling with full support for expression syntax, any expression is
- /// allowed
- Other(Other),
-}
-
-#[cfg(not(feature = "full"))]
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Other {
- _private: (),
-}
-
-#[cfg(feature = "full")]
-pub type Other = Expr;
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use {BinOp, Ty};
- use lit::parsing::lit;
- use op::parsing::{binop, unop};
- use ty::parsing::{path, ty};
-
- named!(pub const_expr -> ConstExpr, do_parse!(
- mut e: alt!(
- expr_unary
- |
- expr_lit
- |
- expr_path
- |
- expr_paren
- // Cannot handle ConstExpr::Other here because for example
- // `[u32; n!()]` would end up successfully parsing `n` as
- // ConstExpr::Path and then fail to parse `!()`. Instead, callers
- // are required to handle Other. See ty::parsing::array_len and
- // data::parsing::discriminant.
- ) >>
- many0!(alt!(
- tap!(args: and_call => {
- e = ConstExpr::Call(Box::new(e), args);
- })
- |
- tap!(more: and_binary => {
- let (op, other) = more;
- e = ConstExpr::Binary(op, Box::new(e), Box::new(other));
- })
- |
- tap!(ty: and_cast => {
- e = ConstExpr::Cast(Box::new(e), Box::new(ty));
- })
- |
- tap!(i: and_index => {
- e = ConstExpr::Index(Box::new(e), Box::new(i));
- })
- )) >>
- (e)
- ));
-
- named!(and_call -> Vec<ConstExpr>, do_parse!(
- punct!("(") >>
- args: terminated_list!(punct!(","), const_expr) >>
- punct!(")") >>
- (args)
- ));
-
- named!(and_binary -> (BinOp, ConstExpr), tuple!(binop, const_expr));
-
- named!(expr_unary -> ConstExpr, do_parse!(
- operator: unop >>
- operand: const_expr >>
- (ConstExpr::Unary(operator, Box::new(operand)))
- ));
-
- named!(expr_lit -> ConstExpr, map!(lit, ConstExpr::Lit));
-
- named!(expr_path -> ConstExpr, map!(path, ConstExpr::Path));
-
- named!(and_index -> ConstExpr, delimited!(punct!("["), const_expr, punct!("]")));
-
- named!(expr_paren -> ConstExpr, do_parse!(
- punct!("(") >>
- e: const_expr >>
- punct!(")") >>
- (ConstExpr::Paren(Box::new(e)))
- ));
-
- named!(and_cast -> Ty, do_parse!(
- keyword!("as") >>
- ty: ty >>
- (ty)
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for ConstExpr {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- ConstExpr::Call(ref func, ref args) => {
- func.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(args, ",");
- tokens.append(")");
- }
- ConstExpr::Binary(op, ref left, ref right) => {
- left.to_tokens(tokens);
- op.to_tokens(tokens);
- right.to_tokens(tokens);
- }
- ConstExpr::Unary(op, ref expr) => {
- op.to_tokens(tokens);
- expr.to_tokens(tokens);
- }
- ConstExpr::Lit(ref lit) => lit.to_tokens(tokens),
- ConstExpr::Cast(ref expr, ref ty) => {
- expr.to_tokens(tokens);
- tokens.append("as");
- ty.to_tokens(tokens);
- }
- ConstExpr::Path(ref path) => path.to_tokens(tokens),
- ConstExpr::Index(ref expr, ref index) => {
- expr.to_tokens(tokens);
- tokens.append("[");
- index.to_tokens(tokens);
- tokens.append("]");
- }
- ConstExpr::Paren(ref expr) => {
- tokens.append("(");
- expr.to_tokens(tokens);
- tokens.append(")");
- }
- ConstExpr::Other(ref other) => {
- other.to_tokens(tokens);
- }
- }
- }
- }
-
- #[cfg(not(feature = "full"))]
- impl ToTokens for Other {
- fn to_tokens(&self, _tokens: &mut Tokens) {
- unreachable!()
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/data.rs
+++ /dev/null
@@ -1,297 +0,0 @@
-use super::*;
-
-/// An enum variant.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Variant {
- /// Name of the variant.
- pub ident: Ident,
-
- /// Attributes tagged on the variant.
- pub attrs: Vec<Attribute>,
-
- /// Type of variant.
- pub data: VariantData,
-
- /// Explicit discriminant, e.g. `Foo = 1`
- pub discriminant: Option<ConstExpr>,
-}
-
-/// Data stored within an enum variant or struct.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum VariantData {
- /// Struct variant, e.g. `Point { x: f64, y: f64 }`.
- Struct(Vec<Field>),
-
- /// Tuple variant, e.g. `Some(T)`.
- Tuple(Vec<Field>),
-
- /// Unit variant, e.g. `None`.
- Unit,
-}
-
-impl VariantData {
- /// Slice containing the fields stored in the variant.
- pub fn fields(&self) -> &[Field] {
- match *self {
- VariantData::Struct(ref fields) |
- VariantData::Tuple(ref fields) => fields,
- VariantData::Unit => &[],
- }
- }
-
- /// Mutable slice containing the fields stored in the variant.
- pub fn fields_mut(&mut self) -> &mut [Field] {
- match *self {
- VariantData::Struct(ref mut fields) |
- VariantData::Tuple(ref mut fields) => fields,
- VariantData::Unit => &mut [],
- }
- }
-}
-
-/// A field of a struct or enum variant.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Field {
- /// Name of the field, if any.
- ///
- /// Fields of tuple structs have no names.
- pub ident: Option<Ident>,
-
- /// Visibility of the field.
- pub vis: Visibility,
-
- /// Attributes tagged on the field.
- pub attrs: Vec<Attribute>,
-
- /// Type of the field.
- pub ty: Ty,
-}
-
-
-/// Visibility level of an item.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Visibility {
- /// Public, i.e. `pub`.
- Public,
-
- /// Crate-visible, i.e. `pub(crate)`.
- Crate,
-
- /// Restricted, e.g. `pub(some::module)`.
- Restricted(Box<Path>),
-
- /// Inherited, i.e. private.
- Inherited,
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use WhereClause;
- #[cfg(feature = "full")]
- use ConstExpr;
- use attr::parsing::outer_attr;
- #[cfg(feature = "full")]
- use constant::parsing::const_expr;
- #[cfg(feature = "full")]
- use expr::parsing::expr;
- use generics::parsing::where_clause;
- use ident::parsing::ident;
- use ty::parsing::{path, ty};
-
- named!(pub struct_body -> (WhereClause, VariantData), alt!(
- do_parse!(
- wh: where_clause >>
- body: struct_like_body >>
- (wh, VariantData::Struct(body))
- )
- |
- do_parse!(
- body: tuple_like_body >>
- wh: where_clause >>
- punct!(";") >>
- (wh, VariantData::Tuple(body))
- )
- |
- do_parse!(
- wh: where_clause >>
- punct!(";") >>
- (wh, VariantData::Unit)
- )
- ));
-
- named!(pub enum_body -> (WhereClause, Vec<Variant>), do_parse!(
- wh: where_clause >>
- punct!("{") >>
- variants: terminated_list!(punct!(","), variant) >>
- punct!("}") >>
- (wh, variants)
- ));
-
- named!(variant -> Variant, do_parse!(
- attrs: many0!(outer_attr) >>
- id: ident >>
- data: alt!(
- struct_like_body => { VariantData::Struct }
- |
- tuple_like_body => { VariantData::Tuple }
- |
- epsilon!() => { |_| VariantData::Unit }
- ) >>
- disr: option!(preceded!(punct!("="), discriminant)) >>
- (Variant {
- ident: id,
- attrs: attrs,
- data: data,
- discriminant: disr,
- })
- ));
-
- #[cfg(not(feature = "full"))]
- use constant::parsing::const_expr as discriminant;
-
- #[cfg(feature = "full")]
- named!(discriminant -> ConstExpr, alt!(
- terminated!(const_expr, after_discriminant)
- |
- terminated!(expr, after_discriminant) => { ConstExpr::Other }
- ));
-
- #[cfg(feature = "full")]
- named!(after_discriminant -> &str, peek!(alt!(punct!(",") | punct!("}"))));
-
- named!(pub struct_like_body -> Vec<Field>, do_parse!(
- punct!("{") >>
- fields: terminated_list!(punct!(","), struct_field) >>
- punct!("}") >>
- (fields)
- ));
-
- named!(tuple_like_body -> Vec<Field>, do_parse!(
- punct!("(") >>
- fields: terminated_list!(punct!(","), tuple_field) >>
- punct!(")") >>
- (fields)
- ));
-
- named!(struct_field -> Field, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- id: ident >>
- punct!(":") >>
- ty: ty >>
- (Field {
- ident: Some(id),
- vis: vis,
- attrs: attrs,
- ty: ty,
- })
- ));
-
- named!(tuple_field -> Field, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- ty: ty >>
- (Field {
- ident: None,
- vis: vis,
- attrs: attrs,
- ty: ty,
- })
- ));
-
- named!(pub visibility -> Visibility, alt!(
- do_parse!(
- keyword!("pub") >>
- punct!("(") >>
- keyword!("crate") >>
- punct!(")") >>
- (Visibility::Crate)
- )
- |
- do_parse!(
- keyword!("pub") >>
- punct!("(") >>
- restricted: path >>
- punct!(")") >>
- (Visibility::Restricted(Box::new(restricted)))
- )
- |
- keyword!("pub") => { |_| Visibility::Public }
- |
- epsilon!() => { |_| Visibility::Inherited }
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Variant {
- fn to_tokens(&self, tokens: &mut Tokens) {
- for attr in &self.attrs {
- attr.to_tokens(tokens);
- }
- self.ident.to_tokens(tokens);
- self.data.to_tokens(tokens);
- if let Some(ref disr) = self.discriminant {
- tokens.append("=");
- disr.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for VariantData {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- VariantData::Struct(ref fields) => {
- tokens.append("{");
- tokens.append_separated(fields, ",");
- tokens.append("}");
- }
- VariantData::Tuple(ref fields) => {
- tokens.append("(");
- tokens.append_separated(fields, ",");
- tokens.append(")");
- }
- VariantData::Unit => {}
- }
- }
- }
-
- impl ToTokens for Field {
- fn to_tokens(&self, tokens: &mut Tokens) {
- for attr in &self.attrs {
- attr.to_tokens(tokens);
- }
- self.vis.to_tokens(tokens);
- if let Some(ref ident) = self.ident {
- ident.to_tokens(tokens);
- tokens.append(":");
- }
- self.ty.to_tokens(tokens);
- }
- }
-
- impl ToTokens for Visibility {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Visibility::Public => tokens.append("pub"),
- Visibility::Crate => {
- tokens.append("pub");
- tokens.append("(");
- tokens.append("crate");
- tokens.append(")");
- }
- Visibility::Restricted(ref path) => {
- tokens.append("pub");
- tokens.append("(");
- path.to_tokens(tokens);
- tokens.append(")");
- }
- Visibility::Inherited => {}
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/derive.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-use super::*;
-
-/// Struct or enum sent to a `proc_macro_derive` macro.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct DeriveInput {
- /// Name of the struct or enum.
- pub ident: Ident,
-
- /// Visibility of the struct or enum.
- pub vis: Visibility,
-
- /// Attributes tagged on the whole struct or enum.
- pub attrs: Vec<Attribute>,
-
- /// Generics required to complete the definition.
- pub generics: Generics,
-
- /// Data within the struct or enum.
- pub body: Body,
-}
-
-/// Body of a derived struct or enum.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Body {
- /// It's an enum.
- Enum(Vec<Variant>),
-
- /// It's a struct.
- Struct(VariantData),
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use Generics;
- use attr::parsing::outer_attr;
- use data::parsing::{visibility, struct_body, enum_body};
- use generics::parsing::generics;
- use ident::parsing::ident;
-
- named!(pub derive_input -> DeriveInput, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- which: alt!(keyword!("struct") | keyword!("enum")) >>
- id: ident >>
- generics: generics >>
- item: switch!(value!(which),
- "struct" => map!(struct_body, move |(wh, body)| DeriveInput {
- ident: id,
- vis: vis,
- attrs: attrs,
- generics: Generics {
- where_clause: wh,
- .. generics
- },
- body: Body::Struct(body),
- })
- |
- "enum" => map!(enum_body, move |(wh, body)| DeriveInput {
- ident: id,
- vis: vis,
- attrs: attrs,
- generics: Generics {
- where_clause: wh,
- .. generics
- },
- body: Body::Enum(body),
- })
- ) >>
- (item)
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use attr::FilterAttrs;
- use data::VariantData;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for DeriveInput {
- fn to_tokens(&self, tokens: &mut Tokens) {
- for attr in self.attrs.outer() {
- attr.to_tokens(tokens);
- }
- self.vis.to_tokens(tokens);
- match self.body {
- Body::Enum(_) => tokens.append("enum"),
- Body::Struct(_) => tokens.append("struct"),
- }
- self.ident.to_tokens(tokens);
- self.generics.to_tokens(tokens);
- match self.body {
- Body::Enum(ref variants) => {
- self.generics.where_clause.to_tokens(tokens);
- tokens.append("{");
- for variant in variants {
- variant.to_tokens(tokens);
- tokens.append(",");
- }
- tokens.append("}");
- }
- Body::Struct(ref variant_data) => {
- match *variant_data {
- VariantData::Struct(_) => {
- self.generics.where_clause.to_tokens(tokens);
- variant_data.to_tokens(tokens);
- // no semicolon
- }
- VariantData::Tuple(_) => {
- variant_data.to_tokens(tokens);
- self.generics.where_clause.to_tokens(tokens);
- tokens.append(";");
- }
- VariantData::Unit => {
- self.generics.where_clause.to_tokens(tokens);
- tokens.append(";");
- }
- }
- }
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/escape.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use std::{char, str};
-use std::num::ParseIntError;
-use synom::IResult;
-
-pub fn cooked_string(input: &str) -> IResult<&str, String> {
- let mut s = String::new();
- let mut chars = input.char_indices().peekable();
- while let Some((byte_offset, ch)) = chars.next() {
- match ch {
- '"' => {
- return IResult::Done(&input[byte_offset..], s);
- }
- '\r' => {
- if let Some((_, '\n')) = chars.next() {
- s.push('\n');
- } else {
- break;
- }
- }
- '\\' => {
- match chars.next() {
- Some((_, 'x')) => {
- match backslash_x_char(&mut chars) {
- Some(ch) => s.push(ch),
- None => break,
- }
- }
- Some((_, 'n')) => s.push('\n'),
- Some((_, 'r')) => s.push('\r'),
- Some((_, 't')) => s.push('\t'),
- Some((_, '\\')) => s.push('\\'),
- Some((_, '0')) => s.push('\0'),
- Some((_, 'u')) => {
- match backslash_u(&mut chars) {
- Some(ch) => s.push(ch),
- None => break,
- }
- }
- Some((_, '\'')) => s.push('\''),
- Some((_, '"')) => s.push('"'),
- Some((_, '\n')) | Some((_, '\r')) => {
- while let Some(&(_, ch)) = chars.peek() {
- if ch.is_whitespace() {
- chars.next();
- } else {
- break;
- }
- }
- }
- _ => break,
- }
- }
- ch => {
- s.push(ch);
- }
- }
- }
- IResult::Error
-}
-
-pub fn cooked_byte_string(mut input: &str) -> IResult<&str, Vec<u8>> {
- let mut vec = Vec::new();
- let mut bytes = input.bytes().enumerate();
- 'outer: while let Some((offset, b)) = bytes.next() {
- match b {
- b'"' => {
- return IResult::Done(&input[offset..], vec);
- }
- b'\r' => {
- if let Some((_, b'\n')) = bytes.next() {
- vec.push(b'\n');
- } else {
- break;
- }
- }
- b'\\' => {
- match bytes.next() {
- Some((_, b'x')) => {
- match backslash_x_byte(&mut bytes) {
- Some(b) => vec.push(b),
- None => break,
- }
- }
- Some((_, b'n')) => vec.push(b'\n'),
- Some((_, b'r')) => vec.push(b'\r'),
- Some((_, b't')) => vec.push(b'\t'),
- Some((_, b'\\')) => vec.push(b'\\'),
- Some((_, b'0')) => vec.push(b'\0'),
- Some((_, b'\'')) => vec.push(b'\''),
- Some((_, b'"')) => vec.push(b'"'),
- Some((newline, b'\n')) |
- Some((newline, b'\r')) => {
- let rest = &input[newline + 1..];
- for (offset, ch) in rest.char_indices() {
- if !ch.is_whitespace() {
- input = &rest[offset..];
- bytes = input.bytes().enumerate();
- continue 'outer;
- }
- }
- break;
- }
- _ => break,
- }
- }
- b if b < 0x80 => {
- vec.push(b);
- }
- _ => break,
- }
- }
- IResult::Error
-}
-
-pub fn cooked_char(input: &str) -> IResult<&str, char> {
- let mut chars = input.char_indices();
- let ch = match chars.next().map(|(_, ch)| ch) {
- Some('\\') => {
- match chars.next().map(|(_, ch)| ch) {
- Some('x') => backslash_x_char(&mut chars),
- Some('n') => Some('\n'),
- Some('r') => Some('\r'),
- Some('t') => Some('\t'),
- Some('\\') => Some('\\'),
- Some('0') => Some('\0'),
- Some('u') => backslash_u(&mut chars),
- Some('\'') => Some('\''),
- Some('"') => Some('"'),
- _ => None,
- }
- }
- ch => ch,
- };
- match ch {
- Some(ch) => IResult::Done(chars.as_str(), ch),
- None => IResult::Error,
- }
-}
-
-pub fn cooked_byte(input: &str) -> IResult<&str, u8> {
- let mut bytes = input.bytes().enumerate();
- let b = match bytes.next().map(|(_, b)| b) {
- Some(b'\\') => {
- match bytes.next().map(|(_, b)| b) {
- Some(b'x') => backslash_x_byte(&mut bytes),
- Some(b'n') => Some(b'\n'),
- Some(b'r') => Some(b'\r'),
- Some(b't') => Some(b'\t'),
- Some(b'\\') => Some(b'\\'),
- Some(b'0') => Some(b'\0'),
- Some(b'\'') => Some(b'\''),
- Some(b'"') => Some(b'"'),
- _ => None,
- }
- }
- b => b,
- };
- match b {
- Some(b) => {
- match bytes.next() {
- Some((offset, _)) => IResult::Done(&input[offset..], b),
- None => IResult::Done("", b),
- }
- }
- None => IResult::Error,
- }
-}
-
-pub fn raw_string(input: &str) -> IResult<&str, (String, usize)> {
- let mut chars = input.char_indices();
- let mut n = 0;
- while let Some((byte_offset, ch)) = chars.next() {
- match ch {
- '"' => {
- n = byte_offset;
- break;
- }
- '#' => {}
- _ => return IResult::Error,
- }
- }
- let mut s = String::new();
- for (byte_offset, ch) in chars {
- match ch {
- '"' if input[byte_offset + 1..].starts_with(&input[..n]) => {
- let rest = &input[byte_offset + 1 + n..];
- return IResult::Done(rest, (s, n));
- }
- '\r' => {}
- _ => s.push(ch),
- }
- }
- IResult::Error
-}
-
-macro_rules! next_ch {
- ($chars:ident @ $pat:pat $(| $rest:pat)*) => {
- match $chars.next() {
- Some((_, ch)) => match ch {
- $pat $(| $rest)* => ch,
- _ => return None,
- },
- None => return None,
- }
- };
-}
-
-trait FromStrRadix: Sized {
- fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError>;
-}
-
-impl FromStrRadix for u8 {
- fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
- u8::from_str_radix(src, radix)
- }
-}
-
-impl FromStrRadix for u32 {
- fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
- u32::from_str_radix(src, radix)
- }
-}
-
-macro_rules! from_hex {
- ($($ch:ident)+) => {{
- let hex_bytes = &[$($ch as u8),*];
- let hex_str = str::from_utf8(hex_bytes).unwrap();
- FromStrRadix::from_str_radix(hex_str, 16).unwrap()
- }};
-}
-
-#[cfg_attr(feature = "cargo-clippy", allow(diverging_sub_expression))]
-fn backslash_x_char<I>(chars: &mut I) -> Option<char>
- where I: Iterator<Item = (usize, char)>
-{
- let a = next_ch!(chars @ '0'...'7');
- let b = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F');
- char::from_u32(from_hex!(a b))
-}
-
-#[cfg_attr(feature = "cargo-clippy", allow(diverging_sub_expression))]
-fn backslash_x_byte<I>(chars: &mut I) -> Option<u8>
- where I: Iterator<Item = (usize, u8)>
-{
- let a = next_ch!(chars @ b'0'...b'9' | b'a'...b'f' | b'A'...b'F');
- let b = next_ch!(chars @ b'0'...b'9' | b'a'...b'f' | b'A'...b'F');
- Some(from_hex!(a b))
-}
-
-#[cfg_attr(feature = "cargo-clippy", allow(diverging_sub_expression, many_single_char_names))]
-fn backslash_u<I>(chars: &mut I) -> Option<char>
- where I: Iterator<Item = (usize, char)>
-{
- next_ch!(chars @ '{');
- let a = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F');
- let b = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '}');
- if b == '}' {
- return char::from_u32(from_hex!(a));
- }
- let c = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '}');
- if c == '}' {
- return char::from_u32(from_hex!(a b));
- }
- let d = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '}');
- if d == '}' {
- return char::from_u32(from_hex!(a b c));
- }
- let e = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '}');
- if e == '}' {
- return char::from_u32(from_hex!(a b c d));
- }
- let f = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '}');
- if f == '}' {
- return char::from_u32(from_hex!(a b c d e));
- }
- next_ch!(chars @ '}');
- char::from_u32(from_hex!(a b c d e f))
-}
-
-#[test]
-fn test_cooked_string() {
- let input = "\\x62 \\\n \\u{7} \\u{64} \\u{bf5} \\u{12ba} \\u{1F395} \\u{102345}\"";
- let expected = "\x62 \u{7} \u{64} \u{bf5} \u{12ba} \u{1F395} \u{102345}";
- assert_eq!(cooked_string(input),
- IResult::Done("\"", expected.to_string()));
-}
-
-#[test]
-fn test_cooked_byte_string() {
- let input = "\\x62 \\\n \\xEF\"";
- let expected = b"\x62 \xEF";
- assert_eq!(cooked_byte_string(input),
- IResult::Done("\"", expected.to_vec()));
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/expr.rs
+++ /dev/null
@@ -1,1721 +0,0 @@
-use super::*;
-
-/// An expression.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Expr {
- /// Type of the expression.
- pub node: ExprKind,
-
- /// Attributes tagged on the expression.
- pub attrs: Vec<Attribute>,
-}
-
-impl From<ExprKind> for Expr {
- fn from(node: ExprKind) -> Expr {
- Expr {
- node: node,
- attrs: Vec::new(),
- }
- }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ExprKind {
- /// A `box x` expression.
- Box(Box<Expr>),
-
- /// First expr is the place; second expr is the value.
- ///
- /// E.g. 'plae <- val'.
- InPlace(Box<Expr>, Box<Expr>),
-
- /// An array, e.g. `[a, b, c, d]`.
- Array(Vec<Expr>),
-
- /// A function call.
- ///
- /// The first field resolves to the function itself,
- /// and the second field is the list of arguments
- Call(Box<Expr>, Vec<Expr>),
-
- /// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
- ///
- /// The `Ident` is the identifier for the method name.
- /// The vector of `Ty`s are the ascripted type parameters for the method
- /// (within the angle brackets).
- ///
- /// The first element of the vector of `Expr`s is the expression that evaluates
- /// to the object on which the method is being called on (the receiver),
- /// and the remaining elements are the rest of the arguments.
- ///
- /// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
- /// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
- MethodCall(Ident, Vec<Ty>, Vec<Expr>),
-
- /// A tuple, e.g. `(a, b, c, d)`.
- Tup(Vec<Expr>),
-
- /// A binary operation, e.g. `a + b`, `a * b`.
- Binary(BinOp, Box<Expr>, Box<Expr>),
-
- /// A unary operation, e.g. `!x`, `*x`.
- Unary(UnOp, Box<Expr>),
-
- /// A literal, e.g. `1`, `"foo"`.
- Lit(Lit),
-
- /// A cast, e.g. `foo as f64`.
- Cast(Box<Expr>, Box<Ty>),
-
- /// A type ascription, e.g. `foo: f64`.
- Type(Box<Expr>, Box<Ty>),
-
- /// An `if` block, with an optional else block
- ///
- /// E.g., `if expr { block } else { expr }`
- If(Box<Expr>, Block, Option<Box<Expr>>),
-
- /// An `if let` expression with an optional else block
- ///
- /// E.g., `if let pat = expr { block } else { expr }`
- ///
- /// This is desugared to a `match` expression.
- IfLet(Box<Pat>, Box<Expr>, Block, Option<Box<Expr>>),
-
- /// A while loop, with an optional label
- ///
- /// E.g., `'label: while expr { block }`
- While(Box<Expr>, Block, Option<Ident>),
-
- /// A while-let loop, with an optional label.
- ///
- /// E.g., `'label: while let pat = expr { block }`
- ///
- /// This is desugared to a combination of `loop` and `match` expressions.
- WhileLet(Box<Pat>, Box<Expr>, Block, Option<Ident>),
-
- /// A for loop, with an optional label.
- ///
- /// E.g., `'label: for pat in expr { block }`
- ///
- /// This is desugared to a combination of `loop` and `match` expressions.
- ForLoop(Box<Pat>, Box<Expr>, Block, Option<Ident>),
-
- /// Conditionless loop with an optional label.
- ///
- /// E.g. `'label: loop { block }`
- Loop(Block, Option<Ident>),
-
- /// A `match` block.
- Match(Box<Expr>, Vec<Arm>),
-
- /// A closure (for example, `move |a, b, c| a + b + c`)
- Closure(CaptureBy, Box<FnDecl>, Box<Expr>),
-
- /// A block (`{ ... }` or `unsafe { ... }`)
- Block(Unsafety, Block),
-
- /// An assignment (`a = foo()`)
- Assign(Box<Expr>, Box<Expr>),
-
- /// An assignment with an operator
- ///
- /// For example, `a += 1`.
- AssignOp(BinOp, Box<Expr>, Box<Expr>),
-
- /// Access of a named struct field (`obj.foo`)
- Field(Box<Expr>, Ident),
-
- /// Access of an unnamed field of a struct or tuple-struct
- ///
- /// For example, `foo.0`.
- TupField(Box<Expr>, usize),
-
- /// An indexing operation (`foo[2]`)
- Index(Box<Expr>, Box<Expr>),
-
- /// A range (`1..2`, `1..`, `..2`, `1...2`, `1...`, `...2`)
- Range(Option<Box<Expr>>, Option<Box<Expr>>, RangeLimits),
-
- /// Variable reference, possibly containing `::` and/or type
- /// parameters, e.g. foo::bar::<baz>.
- ///
- /// Optionally "qualified",
- /// E.g. `<Vec<T> as SomeTrait>::SomeType`.
- Path(Option<QSelf>, Path),
-
- /// A referencing operation (`&a` or `&mut a`)
- AddrOf(Mutability, Box<Expr>),
-
- /// A `break`, with an optional label to break, and an optional expression
- Break(Option<Ident>, Option<Box<Expr>>),
-
- /// A `continue`, with an optional label
- Continue(Option<Ident>),
-
- /// A `return`, with an optional value to be returned
- Ret(Option<Box<Expr>>),
-
- /// A macro invocation; pre-expansion
- Mac(Mac),
-
- /// A struct literal expression.
- ///
- /// For example, `Foo {x: 1, y: 2}`, or
- /// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
- Struct(Path, Vec<FieldValue>, Option<Box<Expr>>),
-
- /// An array literal constructed from one repeated element.
- ///
- /// For example, `[1; 5]`. The first expression is the element
- /// to be repeated; the second is the number of times to repeat it.
- Repeat(Box<Expr>, Box<Expr>),
-
- /// No-op: used solely so we can pretty-print faithfully
- Paren(Box<Expr>),
-
- /// `expr?`
- Try(Box<Expr>),
-}
-
-/// A field-value pair in a struct literal.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FieldValue {
- /// Name of the field.
- pub ident: Ident,
-
- /// Value of the field.
- pub expr: Expr,
-
- /// Whether this is a shorthand field, e.g. `Struct { x }`
- /// instead of `Struct { x: x }`.
- pub is_shorthand: bool,
-
- /// Attributes tagged on the field.
- pub attrs: Vec<Attribute>,
-}
-
-/// A Block (`{ .. }`).
-///
-/// E.g. `{ .. }` as in `fn foo() { .. }`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Block {
- /// Statements in a block
- pub stmts: Vec<Stmt>,
-}
-
-/// A statement, usually ending in a semicolon.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Stmt {
- /// A local (let) binding.
- Local(Box<Local>),
-
- /// An item definition.
- Item(Box<Item>),
-
- /// Expr without trailing semicolon.
- Expr(Box<Expr>),
-
- /// Expression with trailing semicolon;
- Semi(Box<Expr>),
-
- /// Macro invocation.
- Mac(Box<(Mac, MacStmtStyle, Vec<Attribute>)>),
-}
-
-/// How a macro was invoked.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum MacStmtStyle {
- /// The macro statement had a trailing semicolon, e.g. `foo! { ... };`
- /// `foo!(...);`, `foo![...];`
- Semicolon,
-
- /// The macro statement had braces; e.g. foo! { ... }
- Braces,
-
- /// The macro statement had parentheses or brackets and no semicolon; e.g.
- /// `foo!(...)`. All of these will end up being converted into macro
- /// expressions.
- NoBraces,
-}
-
-/// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Local {
- pub pat: Box<Pat>,
- pub ty: Option<Box<Ty>>,
-
- /// Initializer expression to set the value, if any
- pub init: Option<Box<Expr>>,
- pub attrs: Vec<Attribute>,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-// Clippy false positive
-// https://github.com/Manishearth/rust-clippy/issues/1241
-#[cfg_attr(feature = "cargo-clippy", allow(enum_variant_names))]
-pub enum Pat {
- /// Represents a wildcard pattern (`_`)
- Wild,
-
- /// A `Pat::Ident` may either be a new bound variable (`ref mut binding @ OPT_SUBPATTERN`),
- /// or a unit struct/variant pattern, or a const pattern (in the last two cases the third
- /// field must be `None`). Disambiguation cannot be done with parser alone, so it happens
- /// during name resolution.
- Ident(BindingMode, Ident, Option<Box<Pat>>),
-
- /// A struct or struct variant pattern, e.g. `Variant {x, y, ..}`.
- /// The `bool` is `true` in the presence of a `..`.
- Struct(Path, Vec<FieldPat>, bool),
-
- /// A tuple struct/variant pattern `Variant(x, y, .., z)`.
- /// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
- /// 0 <= position <= subpats.len()
- TupleStruct(Path, Vec<Pat>, Option<usize>),
-
- /// A possibly qualified path pattern.
- /// Unquailfied path patterns `A::B::C` can legally refer to variants, structs, constants
- /// or associated constants. Quailfied path patterns `<A>::B::C`/`<A as Trait>::B::C` can
- /// only legally refer to associated constants.
- Path(Option<QSelf>, Path),
-
- /// A tuple pattern `(a, b)`.
- /// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
- /// 0 <= position <= subpats.len()
- Tuple(Vec<Pat>, Option<usize>),
- /// A `box` pattern
- Box(Box<Pat>),
- /// A reference pattern, e.g. `&mut (a, b)`
- Ref(Box<Pat>, Mutability),
- /// A literal
- Lit(Box<Expr>),
- /// A range pattern, e.g. `1...2`
- Range(Box<Expr>, Box<Expr>),
- /// `[a, b, ..i, y, z]` is represented as:
- /// `Pat::Slice(box [a, b], Some(i), box [y, z])`
- Slice(Vec<Pat>, Option<Box<Pat>>, Vec<Pat>),
- /// A macro pattern; pre-expansion
- Mac(Mac),
-}
-
-/// An arm of a 'match'.
-///
-/// E.g. `0...10 => { println!("match!") }` as in
-///
-/// ```rust,ignore
-/// match n {
-/// 0...10 => { println!("match!") },
-/// // ..
-/// }
-/// ```
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Arm {
- pub attrs: Vec<Attribute>,
- pub pats: Vec<Pat>,
- pub guard: Option<Box<Expr>>,
- pub body: Box<Expr>,
-}
-
-/// A capture clause
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum CaptureBy {
- Value,
- Ref,
-}
-
-/// Limit types of a range (inclusive or exclusive)
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum RangeLimits {
- /// Inclusive at the beginning, exclusive at the end
- HalfOpen,
- /// Inclusive at the beginning and end
- Closed,
-}
-
-/// A single field in a struct pattern
-///
-/// Patterns like the fields of Foo `{ x, ref y, ref mut z }`
-/// are treated the same as `x: x, y: ref y, z: ref mut z`,
-/// except `is_shorthand` is true
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FieldPat {
- /// The identifier for the field
- pub ident: Ident,
- /// The pattern the field is destructured to
- pub pat: Box<Pat>,
- pub is_shorthand: bool,
- pub attrs: Vec<Attribute>,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum BindingMode {
- ByRef(Mutability),
- ByValue(Mutability),
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use {BinOp, Delimited, DelimToken, FnArg, FnDecl, FunctionRetTy, Ident, Lifetime, Mac,
- TokenTree, Ty, UnOp, Unsafety};
- use attr::parsing::outer_attr;
- use generics::parsing::lifetime;
- use ident::parsing::{ident, wordlike};
- use item::parsing::item;
- use lit::parsing::{digits, lit};
- use mac::parsing::{mac, token_trees};
- use synom::IResult::{self, Error};
- use op::parsing::{assign_op, binop, unop};
- use ty::parsing::{mutability, path, qpath, ty, unsafety};
-
- // Struct literals are ambiguous in certain positions
- // https://github.com/rust-lang/rfcs/pull/92
- macro_rules! named_ambiguous_expr {
- ($name:ident -> $o:ty, $allow_struct:ident, $submac:ident!( $($args:tt)* )) => {
- fn $name(i: &str, $allow_struct: bool) -> $crate::synom::IResult<&str, $o> {
- $submac!(i, $($args)*)
- }
- };
- }
-
- macro_rules! ambiguous_expr {
- ($i:expr, $allow_struct:ident) => {
- ambiguous_expr($i, $allow_struct, true)
- };
- }
-
- named!(pub expr -> Expr, ambiguous_expr!(true));
-
- named!(expr_no_struct -> Expr, ambiguous_expr!(false));
-
- #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
- fn ambiguous_expr(i: &str, allow_struct: bool, allow_block: bool) -> IResult<&str, Expr> {
- do_parse!(
- i,
- mut e: alt!(
- expr_lit // must be before expr_struct
- |
- cond_reduce!(allow_struct, expr_struct) // must be before expr_path
- |
- expr_paren // must be before expr_tup
- |
- expr_mac // must be before expr_path
- |
- call!(expr_break, allow_struct) // must be before expr_path
- |
- expr_continue // must be before expr_path
- |
- call!(expr_ret, allow_struct) // must be before expr_path
- |
- call!(expr_box, allow_struct)
- |
- expr_in_place
- |
- expr_array
- |
- expr_tup
- |
- call!(expr_unary, allow_struct)
- |
- expr_if
- |
- expr_while
- |
- expr_for_loop
- |
- expr_loop
- |
- expr_match
- |
- call!(expr_closure, allow_struct)
- |
- cond_reduce!(allow_block, expr_block)
- |
- call!(expr_range, allow_struct)
- |
- expr_path
- |
- call!(expr_addr_of, allow_struct)
- |
- expr_repeat
- ) >>
- many0!(alt!(
- tap!(args: and_call => {
- e = ExprKind::Call(Box::new(e.into()), args);
- })
- |
- tap!(more: and_method_call => {
- let (method, ascript, mut args) = more;
- args.insert(0, e.into());
- e = ExprKind::MethodCall(method, ascript, args);
- })
- |
- tap!(more: call!(and_binary, allow_struct) => {
- let (op, other) = more;
- e = ExprKind::Binary(op, Box::new(e.into()), Box::new(other));
- })
- |
- tap!(ty: and_cast => {
- e = ExprKind::Cast(Box::new(e.into()), Box::new(ty));
- })
- |
- tap!(ty: and_ascription => {
- e = ExprKind::Type(Box::new(e.into()), Box::new(ty));
- })
- |
- tap!(v: call!(and_assign, allow_struct) => {
- e = ExprKind::Assign(Box::new(e.into()), Box::new(v));
- })
- |
- tap!(more: call!(and_assign_op, allow_struct) => {
- let (op, v) = more;
- e = ExprKind::AssignOp(op, Box::new(e.into()), Box::new(v));
- })
- |
- tap!(field: and_field => {
- e = ExprKind::Field(Box::new(e.into()), field);
- })
- |
- tap!(field: and_tup_field => {
- e = ExprKind::TupField(Box::new(e.into()), field as usize);
- })
- |
- tap!(i: and_index => {
- e = ExprKind::Index(Box::new(e.into()), Box::new(i));
- })
- |
- tap!(more: call!(and_range, allow_struct) => {
- let (limits, hi) = more;
- e = ExprKind::Range(Some(Box::new(e.into())), hi.map(Box::new), limits);
- })
- |
- tap!(_try: punct!("?") => {
- e = ExprKind::Try(Box::new(e.into()));
- })
- )) >>
- (e.into())
- )
- }
-
- named!(expr_mac -> ExprKind, map!(mac, ExprKind::Mac));
-
- named!(expr_paren -> ExprKind, do_parse!(
- punct!("(") >>
- e: expr >>
- punct!(")") >>
- (ExprKind::Paren(Box::new(e)))
- ));
-
- named_ambiguous_expr!(expr_box -> ExprKind, allow_struct, do_parse!(
- keyword!("box") >>
- inner: ambiguous_expr!(allow_struct) >>
- (ExprKind::Box(Box::new(inner)))
- ));
-
- named!(expr_in_place -> ExprKind, do_parse!(
- keyword!("in") >>
- place: expr_no_struct >>
- punct!("{") >>
- value: within_block >>
- punct!("}") >>
- (ExprKind::InPlace(
- Box::new(place),
- Box::new(ExprKind::Block(Unsafety::Normal, Block {
- stmts: value,
- }).into()),
- ))
- ));
-
- named!(expr_array -> ExprKind, do_parse!(
- punct!("[") >>
- elems: terminated_list!(punct!(","), expr) >>
- punct!("]") >>
- (ExprKind::Array(elems))
- ));
-
- named!(and_call -> Vec<Expr>, do_parse!(
- punct!("(") >>
- args: terminated_list!(punct!(","), expr) >>
- punct!(")") >>
- (args)
- ));
-
- named!(and_method_call -> (Ident, Vec<Ty>, Vec<Expr>), do_parse!(
- punct!(".") >>
- method: ident >>
- ascript: opt_vec!(preceded!(
- punct!("::"),
- delimited!(
- punct!("<"),
- terminated_list!(punct!(","), ty),
- punct!(">")
- )
- )) >>
- punct!("(") >>
- args: terminated_list!(punct!(","), expr) >>
- punct!(")") >>
- (method, ascript, args)
- ));
-
- named!(expr_tup -> ExprKind, do_parse!(
- punct!("(") >>
- elems: terminated_list!(punct!(","), expr) >>
- punct!(")") >>
- (ExprKind::Tup(elems))
- ));
-
- named_ambiguous_expr!(and_binary -> (BinOp, Expr), allow_struct, tuple!(
- binop,
- ambiguous_expr!(allow_struct)
- ));
-
- named_ambiguous_expr!(expr_unary -> ExprKind, allow_struct, do_parse!(
- operator: unop >>
- operand: ambiguous_expr!(allow_struct) >>
- (ExprKind::Unary(operator, Box::new(operand)))
- ));
-
- named!(expr_lit -> ExprKind, map!(lit, ExprKind::Lit));
-
- named!(and_cast -> Ty, do_parse!(
- keyword!("as") >>
- ty: ty >>
- (ty)
- ));
-
- named!(and_ascription -> Ty, preceded!(punct!(":"), ty));
-
- enum Cond {
- Let(Pat, Expr),
- Expr(Expr),
- }
-
- named!(cond -> Cond, alt!(
- do_parse!(
- keyword!("let") >>
- pat: pat >>
- punct!("=") >>
- value: expr_no_struct >>
- (Cond::Let(pat, value))
- )
- |
- map!(expr_no_struct, Cond::Expr)
- ));
-
- named!(expr_if -> ExprKind, do_parse!(
- keyword!("if") >>
- cond: cond >>
- punct!("{") >>
- then_block: within_block >>
- punct!("}") >>
- else_block: option!(preceded!(
- keyword!("else"),
- alt!(
- expr_if
- |
- do_parse!(
- punct!("{") >>
- else_block: within_block >>
- punct!("}") >>
- (ExprKind::Block(Unsafety::Normal, Block {
- stmts: else_block,
- }).into())
- )
- )
- )) >>
- (match cond {
- Cond::Let(pat, expr) => ExprKind::IfLet(
- Box::new(pat),
- Box::new(expr),
- Block {
- stmts: then_block,
- },
- else_block.map(|els| Box::new(els.into())),
- ),
- Cond::Expr(cond) => ExprKind::If(
- Box::new(cond),
- Block {
- stmts: then_block,
- },
- else_block.map(|els| Box::new(els.into())),
- ),
- })
- ));
-
- named!(expr_for_loop -> ExprKind, do_parse!(
- lbl: option!(terminated!(label, punct!(":"))) >>
- keyword!("for") >>
- pat: pat >>
- keyword!("in") >>
- expr: expr_no_struct >>
- loop_block: block >>
- (ExprKind::ForLoop(Box::new(pat), Box::new(expr), loop_block, lbl))
- ));
-
- named!(expr_loop -> ExprKind, do_parse!(
- lbl: option!(terminated!(label, punct!(":"))) >>
- keyword!("loop") >>
- loop_block: block >>
- (ExprKind::Loop(loop_block, lbl))
- ));
-
- named!(expr_match -> ExprKind, do_parse!(
- keyword!("match") >>
- obj: expr_no_struct >>
- punct!("{") >>
- mut arms: many0!(do_parse!(
- arm: match_arm >>
- cond!(arm_requires_comma(&arm), punct!(",")) >>
- cond!(!arm_requires_comma(&arm), option!(punct!(","))) >>
- (arm)
- )) >>
- last_arm: option!(match_arm) >>
- punct!("}") >>
- (ExprKind::Match(Box::new(obj), {
- arms.extend(last_arm);
- arms
- }))
- ));
-
- fn arm_requires_comma(arm: &Arm) -> bool {
- if let ExprKind::Block(Unsafety::Normal, _) = arm.body.node {
- false
- } else {
- true
- }
- }
-
- named!(match_arm -> Arm, do_parse!(
- attrs: many0!(outer_attr) >>
- pats: separated_nonempty_list!(punct!("|"), pat) >>
- guard: option!(preceded!(keyword!("if"), expr)) >>
- punct!("=>") >>
- body: alt!(
- map!(block, |blk| ExprKind::Block(Unsafety::Normal, blk).into())
- |
- expr
- ) >>
- (Arm {
- attrs: attrs,
- pats: pats,
- guard: guard.map(Box::new),
- body: Box::new(body),
- })
- ));
-
- named_ambiguous_expr!(expr_closure -> ExprKind, allow_struct, do_parse!(
- capture: capture_by >>
- punct!("|") >>
- inputs: terminated_list!(punct!(","), closure_arg) >>
- punct!("|") >>
- ret_and_body: alt!(
- do_parse!(
- punct!("->") >>
- ty: ty >>
- body: block >>
- (FunctionRetTy::Ty(ty), ExprKind::Block(Unsafety::Normal, body).into())
- )
- |
- map!(ambiguous_expr!(allow_struct), |e| (FunctionRetTy::Default, e))
- ) >>
- (ExprKind::Closure(
- capture,
- Box::new(FnDecl {
- inputs: inputs,
- output: ret_and_body.0,
- variadic: false,
- }),
- Box::new(ret_and_body.1),
- ))
- ));
-
- named!(closure_arg -> FnArg, do_parse!(
- pat: pat >>
- ty: option!(preceded!(punct!(":"), ty)) >>
- (FnArg::Captured(pat, ty.unwrap_or(Ty::Infer)))
- ));
-
- named!(expr_while -> ExprKind, do_parse!(
- lbl: option!(terminated!(label, punct!(":"))) >>
- keyword!("while") >>
- cond: cond >>
- while_block: block >>
- (match cond {
- Cond::Let(pat, expr) => ExprKind::WhileLet(
- Box::new(pat),
- Box::new(expr),
- while_block,
- lbl,
- ),
- Cond::Expr(cond) => ExprKind::While(
- Box::new(cond),
- while_block,
- lbl,
- ),
- })
- ));
-
- named!(expr_continue -> ExprKind, do_parse!(
- keyword!("continue") >>
- lbl: option!(label) >>
- (ExprKind::Continue(lbl))
- ));
-
- named_ambiguous_expr!(expr_break -> ExprKind, allow_struct, do_parse!(
- keyword!("break") >>
- lbl: option!(label) >>
- val: option!(call!(ambiguous_expr, allow_struct, false)) >>
- (ExprKind::Break(lbl, val.map(Box::new)))
- ));
-
- named_ambiguous_expr!(expr_ret -> ExprKind, allow_struct, do_parse!(
- keyword!("return") >>
- ret_value: option!(ambiguous_expr!(allow_struct)) >>
- (ExprKind::Ret(ret_value.map(Box::new)))
- ));
-
- named!(expr_struct -> ExprKind, do_parse!(
- path: path >>
- punct!("{") >>
- fields: separated_list!(punct!(","), field_value) >>
- base: option!(do_parse!(
- cond!(!fields.is_empty(), punct!(",")) >>
- punct!("..") >>
- base: expr >>
- (base)
- )) >>
- cond!(!fields.is_empty() && base.is_none(), option!(punct!(","))) >>
- punct!("}") >>
- (ExprKind::Struct(path, fields, base.map(Box::new)))
- ));
-
- named!(field_value -> FieldValue, alt!(
- do_parse!(
- name: wordlike >>
- punct!(":") >>
- value: expr >>
- (FieldValue {
- ident: name,
- expr: value,
- is_shorthand: false,
- attrs: Vec::new(),
- })
- )
- |
- map!(ident, |name: Ident| FieldValue {
- ident: name.clone(),
- expr: ExprKind::Path(None, name.into()).into(),
- is_shorthand: true,
- attrs: Vec::new(),
- })
- ));
-
- named!(expr_repeat -> ExprKind, do_parse!(
- punct!("[") >>
- value: expr >>
- punct!(";") >>
- times: expr >>
- punct!("]") >>
- (ExprKind::Repeat(Box::new(value), Box::new(times)))
- ));
-
- named!(expr_block -> ExprKind, do_parse!(
- rules: unsafety >>
- b: block >>
- (ExprKind::Block(rules, Block {
- stmts: b.stmts,
- }))
- ));
-
- named_ambiguous_expr!(expr_range -> ExprKind, allow_struct, do_parse!(
- limits: range_limits >>
- hi: option!(ambiguous_expr!(allow_struct)) >>
- (ExprKind::Range(None, hi.map(Box::new), limits))
- ));
-
- named!(range_limits -> RangeLimits, alt!(
- punct!("...") => { |_| RangeLimits::Closed }
- |
- punct!("..") => { |_| RangeLimits::HalfOpen }
- ));
-
- named!(expr_path -> ExprKind, map!(qpath, |(qself, path)| ExprKind::Path(qself, path)));
-
- named_ambiguous_expr!(expr_addr_of -> ExprKind, allow_struct, do_parse!(
- punct!("&") >>
- mutability: mutability >>
- expr: ambiguous_expr!(allow_struct) >>
- (ExprKind::AddrOf(mutability, Box::new(expr)))
- ));
-
- named_ambiguous_expr!(and_assign -> Expr, allow_struct, preceded!(
- punct!("="),
- ambiguous_expr!(allow_struct)
- ));
-
- named_ambiguous_expr!(and_assign_op -> (BinOp, Expr), allow_struct, tuple!(
- assign_op,
- ambiguous_expr!(allow_struct)
- ));
-
- named!(and_field -> Ident, preceded!(punct!("."), ident));
-
- named!(and_tup_field -> u64, preceded!(punct!("."), digits));
-
- named!(and_index -> Expr, delimited!(punct!("["), expr, punct!("]")));
-
- named_ambiguous_expr!(and_range -> (RangeLimits, Option<Expr>), allow_struct, tuple!(
- range_limits,
- option!(call!(ambiguous_expr, allow_struct, false))
- ));
-
- named!(pub block -> Block, do_parse!(
- punct!("{") >>
- stmts: within_block >>
- punct!("}") >>
- (Block {
- stmts: stmts,
- })
- ));
-
- named!(pub within_block -> Vec<Stmt>, do_parse!(
- many0!(punct!(";")) >>
- mut standalone: many0!(terminated!(stmt, many0!(punct!(";")))) >>
- last: option!(expr) >>
- (match last {
- None => standalone,
- Some(last) => {
- standalone.push(Stmt::Expr(Box::new(last)));
- standalone
- }
- })
- ));
-
- named!(pub stmt -> Stmt, alt!(
- stmt_mac
- |
- stmt_local
- |
- stmt_item
- |
- stmt_expr
- ));
-
- named!(stmt_mac -> Stmt, do_parse!(
- attrs: many0!(outer_attr) >>
- what: path >>
- punct!("!") >>
- // Only parse braces here; paren and bracket will get parsed as
- // expression statements
- punct!("{") >>
- tts: token_trees >>
- punct!("}") >>
- semi: option!(punct!(";")) >>
- (Stmt::Mac(Box::new((
- Mac {
- path: what,
- tts: vec![TokenTree::Delimited(Delimited {
- delim: DelimToken::Brace,
- tts: tts,
- })],
- },
- if semi.is_some() {
- MacStmtStyle::Semicolon
- } else {
- MacStmtStyle::Braces
- },
- attrs,
- ))))
- ));
-
- named!(stmt_local -> Stmt, do_parse!(
- attrs: many0!(outer_attr) >>
- keyword!("let") >>
- pat: pat >>
- ty: option!(preceded!(punct!(":"), ty)) >>
- init: option!(preceded!(punct!("="), expr)) >>
- punct!(";") >>
- (Stmt::Local(Box::new(Local {
- pat: Box::new(pat),
- ty: ty.map(Box::new),
- init: init.map(Box::new),
- attrs: attrs,
- })))
- ));
-
- named!(stmt_item -> Stmt, map!(item, |i| Stmt::Item(Box::new(i))));
-
- fn requires_semi(e: &Expr) -> bool {
- match e.node {
- ExprKind::If(_, _, _) |
- ExprKind::IfLet(_, _, _, _) |
- ExprKind::While(_, _, _) |
- ExprKind::WhileLet(_, _, _, _) |
- ExprKind::ForLoop(_, _, _, _) |
- ExprKind::Loop(_, _) |
- ExprKind::Match(_, _) |
- ExprKind::Block(_, _) => false,
-
- _ => true,
- }
- }
-
- named!(stmt_expr -> Stmt, do_parse!(
- attrs: many0!(outer_attr) >>
- mut e: expr >>
- semi: option!(punct!(";")) >>
- ({
- e.attrs = attrs;
- if semi.is_some() {
- Stmt::Semi(Box::new(e))
- } else if requires_semi(&e) {
- return Error;
- } else {
- Stmt::Expr(Box::new(e))
- }
- })
- ));
-
- named!(pub pat -> Pat, alt!(
- pat_wild // must be before pat_ident
- |
- pat_box // must be before pat_ident
- |
- pat_range // must be before pat_lit
- |
- pat_tuple_struct // must be before pat_ident
- |
- pat_struct // must be before pat_ident
- |
- pat_mac // must be before pat_ident
- |
- pat_lit // must be before pat_ident
- |
- pat_ident // must be before pat_path
- |
- pat_path
- |
- pat_tuple
- |
- pat_ref
- |
- pat_slice
- ));
-
- named!(pat_mac -> Pat, map!(mac, Pat::Mac));
-
- named!(pat_wild -> Pat, map!(keyword!("_"), |_| Pat::Wild));
-
- named!(pat_box -> Pat, do_parse!(
- keyword!("box") >>
- pat: pat >>
- (Pat::Box(Box::new(pat)))
- ));
-
- named!(pat_ident -> Pat, do_parse!(
- mode: option!(keyword!("ref")) >>
- mutability: mutability >>
- name: alt!(
- ident
- |
- keyword!("self") => { Into::into }
- ) >>
- not!(punct!("<")) >>
- not!(punct!("::")) >>
- subpat: option!(preceded!(punct!("@"), pat)) >>
- (Pat::Ident(
- if mode.is_some() {
- BindingMode::ByRef(mutability)
- } else {
- BindingMode::ByValue(mutability)
- },
- name,
- subpat.map(Box::new),
- ))
- ));
-
- named!(pat_tuple_struct -> Pat, do_parse!(
- path: path >>
- tuple: pat_tuple_helper >>
- (Pat::TupleStruct(path, tuple.0, tuple.1))
- ));
-
- named!(pat_struct -> Pat, do_parse!(
- path: path >>
- punct!("{") >>
- fields: separated_list!(punct!(","), field_pat) >>
- more: option!(preceded!(
- cond!(!fields.is_empty(), punct!(",")),
- punct!("..")
- )) >>
- cond!(!fields.is_empty() && more.is_none(), option!(punct!(","))) >>
- punct!("}") >>
- (Pat::Struct(path, fields, more.is_some()))
- ));
-
- named!(field_pat -> FieldPat, alt!(
- do_parse!(
- ident: wordlike >>
- punct!(":") >>
- pat: pat >>
- (FieldPat {
- ident: ident,
- pat: Box::new(pat),
- is_shorthand: false,
- attrs: Vec::new(),
- })
- )
- |
- do_parse!(
- boxed: option!(keyword!("box")) >>
- mode: option!(keyword!("ref")) >>
- mutability: mutability >>
- ident: ident >>
- ({
- let mut pat = Pat::Ident(
- if mode.is_some() {
- BindingMode::ByRef(mutability)
- } else {
- BindingMode::ByValue(mutability)
- },
- ident.clone(),
- None,
- );
- if boxed.is_some() {
- pat = Pat::Box(Box::new(pat));
- }
- FieldPat {
- ident: ident,
- pat: Box::new(pat),
- is_shorthand: true,
- attrs: Vec::new(),
- }
- })
- )
- ));
-
- named!(pat_path -> Pat, map!(qpath, |(qself, path)| Pat::Path(qself, path)));
-
- named!(pat_tuple -> Pat, map!(
- pat_tuple_helper,
- |(pats, dotdot)| Pat::Tuple(pats, dotdot)
- ));
-
- named!(pat_tuple_helper -> (Vec<Pat>, Option<usize>), do_parse!(
- punct!("(") >>
- mut elems: separated_list!(punct!(","), pat) >>
- dotdot: option!(do_parse!(
- cond!(!elems.is_empty(), punct!(",")) >>
- punct!("..") >>
- rest: many0!(preceded!(punct!(","), pat)) >>
- cond!(!rest.is_empty(), option!(punct!(","))) >>
- (rest)
- )) >>
- cond!(!elems.is_empty() && dotdot.is_none(), option!(punct!(","))) >>
- punct!(")") >>
- (match dotdot {
- Some(rest) => {
- let pos = elems.len();
- elems.extend(rest);
- (elems, Some(pos))
- }
- None => (elems, None),
- })
- ));
-
- named!(pat_ref -> Pat, do_parse!(
- punct!("&") >>
- mutability: mutability >>
- pat: pat >>
- (Pat::Ref(Box::new(pat), mutability))
- ));
-
- named!(pat_lit -> Pat, do_parse!(
- lit: pat_lit_expr >>
- (if let ExprKind::Path(_, _) = lit.node {
- return IResult::Error; // these need to be parsed by pat_path
- } else {
- Pat::Lit(Box::new(lit))
- })
- ));
-
- named!(pat_range -> Pat, do_parse!(
- lo: pat_lit_expr >>
- punct!("...") >>
- hi: pat_lit_expr >>
- (Pat::Range(Box::new(lo), Box::new(hi)))
- ));
-
- named!(pat_lit_expr -> Expr, do_parse!(
- neg: option!(punct!("-")) >>
- v: alt!(
- lit => { ExprKind::Lit }
- |
- path => { |p| ExprKind::Path(None, p) }
- ) >>
- (if neg.is_some() {
- ExprKind::Unary(UnOp::Neg, Box::new(v.into())).into()
- } else {
- v.into()
- })
- ));
-
- named!(pat_slice -> Pat, do_parse!(
- punct!("[") >>
- mut before: separated_list!(punct!(","), pat) >>
- after: option!(do_parse!(
- comma_before_dots: option!(cond_reduce!(!before.is_empty(), punct!(","))) >>
- punct!("..") >>
- after: many0!(preceded!(punct!(","), pat)) >>
- cond!(!after.is_empty(), option!(punct!(","))) >>
- (comma_before_dots.is_some(), after)
- )) >>
- cond!(after.is_none(), option!(punct!(","))) >>
- punct!("]") >>
- (match after {
- None => Pat::Slice(before, None, Vec::new()),
- Some((true, after)) => {
- if before.is_empty() {
- return IResult::Error;
- }
- Pat::Slice(before, Some(Box::new(Pat::Wild)), after)
- }
- Some((false, after)) => {
- let rest = before.pop().unwrap_or(Pat::Wild);
- Pat::Slice(before, Some(Box::new(rest)), after)
- }
- })
- ));
-
- named!(capture_by -> CaptureBy, alt!(
- keyword!("move") => { |_| CaptureBy::Value }
- |
- epsilon!() => { |_| CaptureBy::Ref }
- ));
-
- named!(label -> Ident, map!(lifetime, |lt: Lifetime| lt.ident));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use {FnArg, FunctionRetTy, Mutability, Ty, Unsafety};
- use attr::FilterAttrs;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Expr {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- match self.node {
- ExprKind::Box(ref inner) => {
- tokens.append("box");
- inner.to_tokens(tokens);
- }
- ExprKind::InPlace(ref place, ref value) => {
- tokens.append("in");
- place.to_tokens(tokens);
- value.to_tokens(tokens);
- }
- ExprKind::Array(ref tys) => {
- tokens.append("[");
- tokens.append_separated(tys, ",");
- tokens.append("]");
- }
- ExprKind::Call(ref func, ref args) => {
- func.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(args, ",");
- tokens.append(")");
- }
- ExprKind::MethodCall(ref ident, ref ascript, ref args) => {
- args[0].to_tokens(tokens);
- tokens.append(".");
- ident.to_tokens(tokens);
- if !ascript.is_empty() {
- tokens.append("::");
- tokens.append("<");
- tokens.append_separated(ascript, ",");
- tokens.append(">");
- }
- tokens.append("(");
- tokens.append_separated(&args[1..], ",");
- tokens.append(")");
- }
- ExprKind::Tup(ref fields) => {
- tokens.append("(");
- tokens.append_separated(fields, ",");
- if fields.len() == 1 {
- tokens.append(",");
- }
- tokens.append(")");
- }
- ExprKind::Binary(op, ref left, ref right) => {
- left.to_tokens(tokens);
- op.to_tokens(tokens);
- right.to_tokens(tokens);
- }
- ExprKind::Unary(op, ref expr) => {
- op.to_tokens(tokens);
- expr.to_tokens(tokens);
- }
- ExprKind::Lit(ref lit) => lit.to_tokens(tokens),
- ExprKind::Cast(ref expr, ref ty) => {
- expr.to_tokens(tokens);
- tokens.append("as");
- ty.to_tokens(tokens);
- }
- ExprKind::Type(ref expr, ref ty) => {
- expr.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- }
- ExprKind::If(ref cond, ref then_block, ref else_block) => {
- tokens.append("if");
- cond.to_tokens(tokens);
- then_block.to_tokens(tokens);
- if let Some(ref else_block) = *else_block {
- tokens.append("else");
- else_block.to_tokens(tokens);
- }
- }
- ExprKind::IfLet(ref pat, ref expr, ref then_block, ref else_block) => {
- tokens.append("if");
- tokens.append("let");
- pat.to_tokens(tokens);
- tokens.append("=");
- expr.to_tokens(tokens);
- then_block.to_tokens(tokens);
- if let Some(ref else_block) = *else_block {
- tokens.append("else");
- else_block.to_tokens(tokens);
- }
- }
- ExprKind::While(ref cond, ref body, ref label) => {
- if let Some(ref label) = *label {
- label.to_tokens(tokens);
- tokens.append(":");
- }
- tokens.append("while");
- cond.to_tokens(tokens);
- body.to_tokens(tokens);
- }
- ExprKind::WhileLet(ref pat, ref expr, ref body, ref label) => {
- if let Some(ref label) = *label {
- label.to_tokens(tokens);
- tokens.append(":");
- }
- tokens.append("while");
- tokens.append("let");
- pat.to_tokens(tokens);
- tokens.append("=");
- expr.to_tokens(tokens);
- body.to_tokens(tokens);
- }
- ExprKind::ForLoop(ref pat, ref expr, ref body, ref label) => {
- if let Some(ref label) = *label {
- label.to_tokens(tokens);
- tokens.append(":");
- }
- tokens.append("for");
- pat.to_tokens(tokens);
- tokens.append("in");
- expr.to_tokens(tokens);
- body.to_tokens(tokens);
- }
- ExprKind::Loop(ref body, ref label) => {
- if let Some(ref label) = *label {
- label.to_tokens(tokens);
- tokens.append(":");
- }
- tokens.append("loop");
- body.to_tokens(tokens);
- }
- ExprKind::Match(ref expr, ref arms) => {
- tokens.append("match");
- expr.to_tokens(tokens);
- tokens.append("{");
- tokens.append_all(arms);
- tokens.append("}");
- }
- ExprKind::Closure(capture, ref decl, ref expr) => {
- capture.to_tokens(tokens);
- tokens.append("|");
- for (i, input) in decl.inputs.iter().enumerate() {
- if i > 0 {
- tokens.append(",");
- }
- match *input {
- FnArg::Captured(ref pat, Ty::Infer) => {
- pat.to_tokens(tokens);
- }
- _ => input.to_tokens(tokens),
- }
- }
- tokens.append("|");
- match decl.output {
- FunctionRetTy::Default => { /* nothing */ }
- FunctionRetTy::Ty(ref ty) => {
- tokens.append("->");
- ty.to_tokens(tokens);
- }
- }
- expr.to_tokens(tokens);
- }
- ExprKind::Block(rules, ref block) => {
- rules.to_tokens(tokens);
- block.to_tokens(tokens);
- }
- ExprKind::Assign(ref var, ref expr) => {
- var.to_tokens(tokens);
- tokens.append("=");
- expr.to_tokens(tokens);
- }
- ExprKind::AssignOp(op, ref var, ref expr) => {
- var.to_tokens(tokens);
- tokens.append(op.assign_op().unwrap());
- expr.to_tokens(tokens);
- }
- ExprKind::Field(ref expr, ref field) => {
- expr.to_tokens(tokens);
- tokens.append(".");
- field.to_tokens(tokens);
- }
- ExprKind::TupField(ref expr, field) => {
- expr.to_tokens(tokens);
- tokens.append(".");
- tokens.append(&field.to_string());
- }
- ExprKind::Index(ref expr, ref index) => {
- expr.to_tokens(tokens);
- tokens.append("[");
- index.to_tokens(tokens);
- tokens.append("]");
- }
- ExprKind::Range(ref from, ref to, limits) => {
- from.to_tokens(tokens);
- match limits {
- RangeLimits::HalfOpen => tokens.append(".."),
- RangeLimits::Closed => tokens.append("..."),
- }
- to.to_tokens(tokens);
- }
- ExprKind::Path(None, ref path) => path.to_tokens(tokens),
- ExprKind::Path(Some(ref qself), ref path) => {
- tokens.append("<");
- qself.ty.to_tokens(tokens);
- if qself.position > 0 {
- tokens.append("as");
- for (i, segment) in path.segments
- .iter()
- .take(qself.position)
- .enumerate() {
- if i > 0 || path.global {
- tokens.append("::");
- }
- segment.to_tokens(tokens);
- }
- }
- tokens.append(">");
- for segment in path.segments.iter().skip(qself.position) {
- tokens.append("::");
- segment.to_tokens(tokens);
- }
- }
- ExprKind::AddrOf(mutability, ref expr) => {
- tokens.append("&");
- mutability.to_tokens(tokens);
- expr.to_tokens(tokens);
- }
- ExprKind::Break(ref opt_label, ref opt_val) => {
- tokens.append("break");
- opt_label.to_tokens(tokens);
- opt_val.to_tokens(tokens);
- }
- ExprKind::Continue(ref opt_label) => {
- tokens.append("continue");
- opt_label.to_tokens(tokens);
- }
- ExprKind::Ret(ref opt_expr) => {
- tokens.append("return");
- opt_expr.to_tokens(tokens);
- }
- ExprKind::Mac(ref mac) => mac.to_tokens(tokens),
- ExprKind::Struct(ref path, ref fields, ref base) => {
- path.to_tokens(tokens);
- tokens.append("{");
- tokens.append_separated(fields, ",");
- if let Some(ref base) = *base {
- if !fields.is_empty() {
- tokens.append(",");
- }
- tokens.append("..");
- base.to_tokens(tokens);
- }
- tokens.append("}");
- }
- ExprKind::Repeat(ref expr, ref times) => {
- tokens.append("[");
- expr.to_tokens(tokens);
- tokens.append(";");
- times.to_tokens(tokens);
- tokens.append("]");
- }
- ExprKind::Paren(ref expr) => {
- tokens.append("(");
- expr.to_tokens(tokens);
- tokens.append(")");
- }
- ExprKind::Try(ref expr) => {
- expr.to_tokens(tokens);
- tokens.append("?");
- }
- }
- }
- }
-
- impl ToTokens for FieldValue {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.ident.to_tokens(tokens);
- if !self.is_shorthand {
- tokens.append(":");
- self.expr.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for Arm {
- fn to_tokens(&self, tokens: &mut Tokens) {
- for attr in &self.attrs {
- attr.to_tokens(tokens);
- }
- tokens.append_separated(&self.pats, "|");
- if let Some(ref guard) = self.guard {
- tokens.append("if");
- guard.to_tokens(tokens);
- }
- tokens.append("=>");
- self.body.to_tokens(tokens);
- match self.body.node {
- ExprKind::Block(Unsafety::Normal, _) => {
- // no comma
- }
- _ => tokens.append(","),
- }
- }
- }
-
- impl ToTokens for Pat {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Pat::Wild => tokens.append("_"),
- Pat::Ident(mode, ref ident, ref subpat) => {
- mode.to_tokens(tokens);
- ident.to_tokens(tokens);
- if let Some(ref subpat) = *subpat {
- tokens.append("@");
- subpat.to_tokens(tokens);
- }
- }
- Pat::Struct(ref path, ref fields, dots) => {
- path.to_tokens(tokens);
- tokens.append("{");
- tokens.append_separated(fields, ",");
- if dots {
- if !fields.is_empty() {
- tokens.append(",");
- }
- tokens.append("..");
- }
- tokens.append("}");
- }
- Pat::TupleStruct(ref path, ref pats, dotpos) => {
- path.to_tokens(tokens);
- tokens.append("(");
- match dotpos {
- Some(pos) => {
- if pos > 0 {
- tokens.append_separated(&pats[..pos], ",");
- tokens.append(",");
- }
- tokens.append("..");
- if pos < pats.len() {
- tokens.append(",");
- tokens.append_separated(&pats[pos..], ",");
- }
- }
- None => tokens.append_separated(pats, ","),
- }
- tokens.append(")");
- }
- Pat::Path(None, ref path) => path.to_tokens(tokens),
- Pat::Path(Some(ref qself), ref path) => {
- tokens.append("<");
- qself.ty.to_tokens(tokens);
- if qself.position > 0 {
- tokens.append("as");
- for (i, segment) in path.segments
- .iter()
- .take(qself.position)
- .enumerate() {
- if i > 0 || path.global {
- tokens.append("::");
- }
- segment.to_tokens(tokens);
- }
- }
- tokens.append(">");
- for segment in path.segments.iter().skip(qself.position) {
- tokens.append("::");
- segment.to_tokens(tokens);
- }
- }
- Pat::Tuple(ref pats, dotpos) => {
- tokens.append("(");
- match dotpos {
- Some(pos) => {
- if pos > 0 {
- tokens.append_separated(&pats[..pos], ",");
- tokens.append(",");
- }
- tokens.append("..");
- if pos < pats.len() {
- tokens.append(",");
- tokens.append_separated(&pats[pos..], ",");
- }
- }
- None => {
- tokens.append_separated(pats, ",");
- if pats.len() == 1 {
- tokens.append(",");
- }
- }
- }
- tokens.append(")");
- }
- Pat::Box(ref inner) => {
- tokens.append("box");
- inner.to_tokens(tokens);
- }
- Pat::Ref(ref target, mutability) => {
- tokens.append("&");
- mutability.to_tokens(tokens);
- target.to_tokens(tokens);
- }
- Pat::Lit(ref lit) => lit.to_tokens(tokens),
- Pat::Range(ref lo, ref hi) => {
- lo.to_tokens(tokens);
- tokens.append("...");
- hi.to_tokens(tokens);
- }
- Pat::Slice(ref before, ref rest, ref after) => {
- tokens.append("[");
- tokens.append_separated(before, ",");
- if let Some(ref rest) = *rest {
- if !before.is_empty() {
- tokens.append(",");
- }
- if **rest != Pat::Wild {
- rest.to_tokens(tokens);
- }
- tokens.append("..");
- if !after.is_empty() {
- tokens.append(",");
- }
- tokens.append_separated(after, ",");
- }
- tokens.append("]");
- }
- Pat::Mac(ref mac) => mac.to_tokens(tokens),
- }
- }
- }
-
- impl ToTokens for FieldPat {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if !self.is_shorthand {
- self.ident.to_tokens(tokens);
- tokens.append(":");
- }
- self.pat.to_tokens(tokens);
- }
- }
-
- impl ToTokens for BindingMode {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- BindingMode::ByRef(Mutability::Immutable) => {
- tokens.append("ref");
- }
- BindingMode::ByRef(Mutability::Mutable) => {
- tokens.append("ref");
- tokens.append("mut");
- }
- BindingMode::ByValue(Mutability::Immutable) => {}
- BindingMode::ByValue(Mutability::Mutable) => {
- tokens.append("mut");
- }
- }
- }
- }
-
- impl ToTokens for CaptureBy {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- CaptureBy::Value => tokens.append("move"),
- CaptureBy::Ref => {
- // nothing
- }
- }
- }
- }
-
- impl ToTokens for Block {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append("{");
- tokens.append_all(&self.stmts);
- tokens.append("}");
- }
- }
-
- impl ToTokens for Stmt {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Stmt::Local(ref local) => local.to_tokens(tokens),
- Stmt::Item(ref item) => item.to_tokens(tokens),
- Stmt::Expr(ref expr) => expr.to_tokens(tokens),
- Stmt::Semi(ref expr) => {
- expr.to_tokens(tokens);
- tokens.append(";");
- }
- Stmt::Mac(ref mac) => {
- let (ref mac, style, ref attrs) = **mac;
- tokens.append_all(attrs.outer());
- mac.to_tokens(tokens);
- match style {
- MacStmtStyle::Semicolon => tokens.append(";"),
- MacStmtStyle::Braces | MacStmtStyle::NoBraces => {
- // no semicolon
- }
- }
- }
- }
- }
- }
-
- impl ToTokens for Local {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- tokens.append("let");
- self.pat.to_tokens(tokens);
- if let Some(ref ty) = self.ty {
- tokens.append(":");
- ty.to_tokens(tokens);
- }
- if let Some(ref init) = self.init {
- tokens.append("=");
- init.to_tokens(tokens);
- }
- tokens.append(";");
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/fold.rs
+++ /dev/null
@@ -1,942 +0,0 @@
-// Adapted from libsyntax.
-
-//! A Folder represents an AST->AST fold; it accepts an AST piece,
-//! and returns a piece of the same type.
-
-use super::*;
-#[cfg(not(feature = "full"))]
-use constant;
-
-/// AST->AST fold.
-///
-/// Each method of the Folder trait is a hook to be potentially overridden. Each
-/// method's default implementation recursively visits the substructure of the
-/// input via the `noop_fold` methods, which perform an "identity fold", that
-/// is, they return the same structure that they are given (for example the
-/// `fold_crate` method by default calls `fold::noop_fold_crate`).
-///
-/// If you want to ensure that your code handles every variant explicitly, you
-/// need to override each method and monitor future changes to `Folder` in case
-/// a new method with a new default implementation gets introduced.
-pub trait Folder {
- // Any additions to this trait should happen in form
- // of a call to a public `noop_*` function that only calls
- // out to the folder again, not other `noop_*` functions.
- //
- // This is a necessary API workaround to the problem of not
- // being able to call out to the super default method
- // in an overridden default method.
-
- fn fold_ident(&mut self, _ident: Ident) -> Ident {
- noop_fold_ident(self, _ident)
- }
- fn fold_derive_input(&mut self, derive_input: DeriveInput) -> DeriveInput {
- noop_fold_derive_input(self, derive_input)
- }
- fn fold_ty(&mut self, ty: Ty) -> Ty {
- noop_fold_ty(self, ty)
- }
- fn fold_generics(&mut self, generics: Generics) -> Generics {
- noop_fold_generics(self, generics)
- }
- fn fold_ty_param_bound(&mut self, bound: TyParamBound) -> TyParamBound {
- noop_fold_ty_param_bound(self, bound)
- }
- fn fold_poly_trait_ref(&mut self, trait_ref: PolyTraitRef) -> PolyTraitRef {
- noop_fold_poly_trait_ref(self, trait_ref)
- }
- fn fold_variant_data(&mut self, data: VariantData) -> VariantData {
- noop_fold_variant_data(self, data)
- }
- fn fold_field(&mut self, field: Field) -> Field {
- noop_fold_field(self, field)
- }
- fn fold_variant(&mut self, variant: Variant) -> Variant {
- noop_fold_variant(self, variant)
- }
- fn fold_lifetime(&mut self, _lifetime: Lifetime) -> Lifetime {
- noop_fold_lifetime(self, _lifetime)
- }
- fn fold_lifetime_def(&mut self, lifetime: LifetimeDef) -> LifetimeDef {
- noop_fold_lifetime_def(self, lifetime)
- }
- fn fold_path(&mut self, path: Path) -> Path {
- noop_fold_path(self, path)
- }
- fn fold_path_segment(&mut self, path_segment: PathSegment) -> PathSegment {
- noop_fold_path_segment(self, path_segment)
- }
- fn fold_path_parameters(&mut self, path_parameters: PathParameters) -> PathParameters {
- noop_fold_path_parameters(self, path_parameters)
- }
- fn fold_assoc_type_binding(&mut self, type_binding: TypeBinding) -> TypeBinding {
- noop_fold_assoc_type_binding(self, type_binding)
- }
- fn fold_attribute(&mut self, _attr: Attribute) -> Attribute {
- noop_fold_attribute(self, _attr)
- }
- fn fold_fn_ret_ty(&mut self, ret_ty: FunctionRetTy) -> FunctionRetTy {
- noop_fold_fn_ret_ty(self, ret_ty)
- }
- fn fold_const_expr(&mut self, expr: ConstExpr) -> ConstExpr {
- noop_fold_const_expr(self, expr)
- }
- fn fold_lit(&mut self, _lit: Lit) -> Lit {
- noop_fold_lit(self, _lit)
- }
-
- fn fold_mac(&mut self, mac: Mac) -> Mac {
- noop_fold_mac(self, mac)
- }
-
- #[cfg(feature = "full")]
- fn fold_crate(&mut self, _crate: Crate) -> Crate {
- noop_fold_crate(self, _crate)
- }
- #[cfg(feature = "full")]
- fn fold_item(&mut self, item: Item) -> Item {
- noop_fold_item(self, item)
- }
- #[cfg(feature = "full")]
- fn fold_expr(&mut self, expr: Expr) -> Expr {
- noop_fold_expr(self, expr)
- }
- #[cfg(feature = "full")]
- fn fold_foreign_item(&mut self, foreign_item: ForeignItem) -> ForeignItem {
- noop_fold_foreign_item(self, foreign_item)
- }
- #[cfg(feature = "full")]
- fn fold_pat(&mut self, pat: Pat) -> Pat {
- noop_fold_pat(self, pat)
- }
- #[cfg(feature = "full")]
- fn fold_fn_decl(&mut self, fn_decl: FnDecl) -> FnDecl {
- noop_fold_fn_decl(self, fn_decl)
- }
- #[cfg(feature = "full")]
- fn fold_trait_item(&mut self, trait_item: TraitItem) -> TraitItem {
- noop_fold_trait_item(self, trait_item)
- }
- #[cfg(feature = "full")]
- fn fold_impl_item(&mut self, impl_item: ImplItem) -> ImplItem {
- noop_fold_impl_item(self, impl_item)
- }
- #[cfg(feature = "full")]
- fn fold_method_sig(&mut self, method_sig: MethodSig) -> MethodSig {
- noop_fold_method_sig(self, method_sig)
- }
- #[cfg(feature = "full")]
- fn fold_stmt(&mut self, stmt: Stmt) -> Stmt {
- noop_fold_stmt(self, stmt)
- }
- #[cfg(feature = "full")]
- fn fold_block(&mut self, block: Block) -> Block {
- noop_fold_block(self, block)
- }
- #[cfg(feature = "full")]
- fn fold_local(&mut self, local: Local) -> Local {
- noop_fold_local(self, local)
- }
- #[cfg(feature = "full")]
- fn fold_view_path(&mut self, view_path: ViewPath) -> ViewPath {
- noop_fold_view_path(self, view_path)
- }
-}
-
-trait LiftOnce<T, U> {
- type Output;
- fn lift<F>(self, f: F) -> Self::Output where F: FnOnce(T) -> U;
-}
-
-impl<T, U> LiftOnce<T, U> for Box<T> {
- type Output = Box<U>;
- // Clippy false positive
- // https://github.com/Manishearth/rust-clippy/issues/1478
- #[cfg_attr(feature = "cargo-clippy", allow(boxed_local))]
- fn lift<F>(self, f: F) -> Box<U>
- where F: FnOnce(T) -> U
- {
- Box::new(f(*self))
- }
-}
-
-trait LiftMut<T, U> {
- type Output;
- fn lift<F>(self, f: F) -> Self::Output where F: FnMut(T) -> U;
-}
-
-impl<T, U> LiftMut<T, U> for Vec<T> {
- type Output = Vec<U>;
- fn lift<F>(self, f: F) -> Vec<U>
- where F: FnMut(T) -> U
- {
- self.into_iter().map(f).collect()
- }
-}
-
-pub fn noop_fold_ident<F: ?Sized + Folder>(_: &mut F, _ident: Ident) -> Ident {
- _ident
-}
-
-pub fn noop_fold_derive_input<F: ?Sized + Folder>(folder: &mut F,
- DeriveInput{ ident,
- vis,
- attrs,
- generics,
-body }: DeriveInput) -> DeriveInput{
- use Body::*;
- DeriveInput {
- ident: folder.fold_ident(ident),
- vis: noop_fold_vis(folder, vis),
- attrs: attrs.lift(|a| folder.fold_attribute(a)),
- generics: folder.fold_generics(generics),
- body: match body {
- Enum(variants) => Enum(variants.lift(move |v| folder.fold_variant(v))),
- Struct(variant_data) => Struct(folder.fold_variant_data(variant_data)),
- },
- }
-}
-
-pub fn noop_fold_ty<F: ?Sized + Folder>(folder: &mut F, ty: Ty) -> Ty {
- use Ty::*;
- match ty {
- Slice(inner) => Slice(inner.lift(|v| folder.fold_ty(v))),
- Paren(inner) => Paren(inner.lift(|v| folder.fold_ty(v))),
- Ptr(mutable_type) => {
- let mutable_type_ = *mutable_type;
- let MutTy { ty, mutability }: MutTy = mutable_type_;
- Ptr(Box::new(MutTy {
- ty: folder.fold_ty(ty),
- mutability: mutability,
- }))
- }
- Rptr(opt_lifetime, mutable_type) => {
- let mutable_type_ = *mutable_type;
- let MutTy { ty, mutability }: MutTy = mutable_type_;
- Rptr(opt_lifetime.map(|l| folder.fold_lifetime(l)),
- Box::new(MutTy {
- ty: folder.fold_ty(ty),
- mutability: mutability,
- }))
- }
- Never => Never,
- Infer => Infer,
- Tup(tuple_element_types) => Tup(tuple_element_types.lift(|x| folder.fold_ty(x))),
- BareFn(bare_fn) => {
- let bf_ = *bare_fn;
- let BareFnTy { unsafety, abi, lifetimes, inputs, output, variadic } = bf_;
- BareFn(Box::new(BareFnTy {
- unsafety: unsafety,
- abi: abi,
- lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
- inputs: inputs.lift(|v| {
- BareFnArg {
- name: v.name.map(|n| folder.fold_ident(n)),
- ty: folder.fold_ty(v.ty),
- }
- }),
- output: folder.fold_fn_ret_ty(output),
- variadic: variadic,
- }))
- }
- Path(maybe_qself, path) => {
- Path(maybe_qself.map(|v| noop_fold_qself(folder, v)),
- folder.fold_path(path))
- }
- Array(inner, len) => {
- Array({
- inner.lift(|v| folder.fold_ty(v))
- },
- folder.fold_const_expr(len))
- }
- TraitObject(bounds) => TraitObject(bounds.lift(|v| folder.fold_ty_param_bound(v))),
- ImplTrait(bounds) => ImplTrait(bounds.lift(|v| folder.fold_ty_param_bound(v))),
- Mac(mac) => Mac(folder.fold_mac(mac)),
- }
-}
-
-fn noop_fold_qself<F: ?Sized + Folder>(folder: &mut F, QSelf { ty, position }: QSelf) -> QSelf {
- QSelf {
- ty: Box::new(folder.fold_ty(*(ty))),
- position: position,
- }
-}
-
-pub fn noop_fold_generics<F: ?Sized + Folder>(folder: &mut F,
- Generics { lifetimes, ty_params, where_clause }: Generics)
--> Generics{
- use WherePredicate::*;
- Generics {
- lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
- ty_params: ty_params.lift(|ty| {
- TyParam {
- attrs: ty.attrs.lift(|a| folder.fold_attribute(a)),
- ident: folder.fold_ident(ty.ident),
- bounds: ty.bounds.lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
- default: ty.default.map(|v| folder.fold_ty(v)),
- }
- }),
- where_clause: WhereClause {
- predicates: where_clause.predicates.lift(|p| match p {
- BoundPredicate(bound_predicate) => {
- BoundPredicate(WhereBoundPredicate {
- bound_lifetimes: bound_predicate.bound_lifetimes
- .lift(|l| folder.fold_lifetime_def(l)),
- bounded_ty: folder.fold_ty(bound_predicate.bounded_ty),
- bounds: bound_predicate.bounds
- .lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
- })
- }
- RegionPredicate(region_predicate) => {
- RegionPredicate(WhereRegionPredicate {
- lifetime: folder.fold_lifetime(region_predicate.lifetime),
- bounds: region_predicate.bounds
- .lift(|b| folder.fold_lifetime(b)),
- })
- }
- EqPredicate(eq_predicate) => {
- EqPredicate(WhereEqPredicate {
- lhs_ty: folder.fold_ty(eq_predicate.lhs_ty),
- rhs_ty: folder.fold_ty(eq_predicate.rhs_ty),
- })
- }
- }),
- },
- }
-}
-
-pub fn noop_fold_ty_param_bound<F: ?Sized + Folder>(folder: &mut F,
- bound: TyParamBound)
- -> TyParamBound {
- use TyParamBound::*;
- match bound {
- Trait(ty, modifier) => Trait(folder.fold_poly_trait_ref(ty), modifier),
- Region(lifetime) => Region(folder.fold_lifetime(lifetime)),
- }
-}
-
-pub fn noop_fold_poly_trait_ref<F: ?Sized + Folder>(folder: &mut F,
- trait_ref: PolyTraitRef)
- -> PolyTraitRef {
- PolyTraitRef {
- bound_lifetimes: trait_ref.bound_lifetimes.lift(|bl| folder.fold_lifetime_def(bl)),
- trait_ref: folder.fold_path(trait_ref.trait_ref),
- }
-}
-
-pub fn noop_fold_variant_data<F: ?Sized + Folder>(folder: &mut F,
- data: VariantData)
- -> VariantData {
- use VariantData::*;
- match data {
- Struct(fields) => Struct(fields.lift(|f| folder.fold_field(f))),
- Tuple(fields) => Tuple(fields.lift(|f| folder.fold_field(f))),
- Unit => Unit,
- }
-}
-
-pub fn noop_fold_field<F: ?Sized + Folder>(folder: &mut F, field: Field) -> Field {
- Field {
- ident: field.ident.map(|i| folder.fold_ident(i)),
- vis: noop_fold_vis(folder, field.vis),
- attrs: field.attrs.lift(|a| folder.fold_attribute(a)),
- ty: folder.fold_ty(field.ty),
- }
-}
-
-pub fn noop_fold_variant<F: ?Sized + Folder>(folder: &mut F,
- Variant { ident, attrs, data, discriminant }: Variant)
--> Variant{
- Variant {
- ident: folder.fold_ident(ident),
- attrs: attrs.lift(|v| folder.fold_attribute(v)),
- data: folder.fold_variant_data(data),
- discriminant: discriminant.map(|ce| folder.fold_const_expr(ce)),
- }
-}
-
-pub fn noop_fold_lifetime<F: ?Sized + Folder>(folder: &mut F, _lifetime: Lifetime) -> Lifetime {
- Lifetime { ident: folder.fold_ident(_lifetime.ident) }
-}
-
-pub fn noop_fold_lifetime_def<F: ?Sized + Folder>(folder: &mut F,
- LifetimeDef { attrs, lifetime, bounds }: LifetimeDef)
--> LifetimeDef{
- LifetimeDef {
- attrs: attrs.lift(|x| folder.fold_attribute(x)),
- lifetime: folder.fold_lifetime(lifetime),
- bounds: bounds.lift(|l| folder.fold_lifetime(l)),
- }
-}
-
-pub fn noop_fold_path<F: ?Sized + Folder>(folder: &mut F, Path { global, segments }: Path) -> Path {
- Path {
- global: global,
- segments: segments.lift(|s| folder.fold_path_segment(s)),
- }
-}
-
-pub fn noop_fold_path_segment<F: ?Sized + Folder>(folder: &mut F,
- PathSegment { ident, parameters }: PathSegment)
- -> PathSegment {
- PathSegment {
- ident: folder.fold_ident(ident),
- parameters: folder.fold_path_parameters(parameters),
- }
-}
-
-pub fn noop_fold_path_parameters<F: ?Sized + Folder>(folder: &mut F,
- path_parameters: PathParameters)
- -> PathParameters {
- use PathParameters::*;
- match path_parameters {
- AngleBracketed(d) => {
- let AngleBracketedParameterData { lifetimes, types, bindings } = d;
- AngleBracketed(AngleBracketedParameterData {
- lifetimes: lifetimes.into_iter()
- .map(|l| folder.fold_lifetime(l))
- .collect(),
- types: types.lift(|ty| folder.fold_ty(ty)),
- bindings: bindings.lift(|tb| folder.fold_assoc_type_binding(tb)),
- })
- }
- Parenthesized(d) => {
- let ParenthesizedParameterData { inputs, output } = d;
- Parenthesized(ParenthesizedParameterData {
- inputs: inputs.lift(|i| folder.fold_ty(i)),
- output: output.map(|v| folder.fold_ty(v)),
- })
- }
- }
-}
-
-pub fn noop_fold_assoc_type_binding<F: ?Sized + Folder>(folder: &mut F,
- TypeBinding { ident, ty }: TypeBinding)
- -> TypeBinding {
- TypeBinding {
- ident: folder.fold_ident(ident),
- ty: folder.fold_ty(ty),
- }
-
-}
-
-pub fn noop_fold_attribute<F: ?Sized + Folder>(_: &mut F, _attr: Attribute) -> Attribute {
- _attr
-}
-
-pub fn noop_fold_fn_ret_ty<F: ?Sized + Folder>(folder: &mut F,
- ret_ty: FunctionRetTy)
- -> FunctionRetTy {
- use FunctionRetTy::*;
- match ret_ty {
- Default => Default,
- Ty(ty) => Ty(folder.fold_ty(ty)),
- }
-}
-
-pub fn noop_fold_const_expr<F: ?Sized + Folder>(folder: &mut F, expr: ConstExpr) -> ConstExpr {
- use ConstExpr::*;
- match expr {
- Call(f, args) => {
- Call(f.lift(|e| folder.fold_const_expr(e)),
- args.lift(|v| folder.fold_const_expr(v)))
- }
- Binary(op, lhs, rhs) => {
- Binary(op,
- lhs.lift(|e| folder.fold_const_expr(e)),
- rhs.lift(|e| folder.fold_const_expr(e)))
- }
- Unary(op, e) => Unary(op, e.lift(|e| folder.fold_const_expr(e))),
- Lit(l) => Lit(folder.fold_lit(l)),
- Cast(e, ty) => {
- Cast(e.lift(|e| folder.fold_const_expr(e)),
- ty.lift(|v| folder.fold_ty(v)))
- }
- Path(p) => Path(folder.fold_path(p)),
- Index(o, i) => {
- Index(o.lift(|e| folder.fold_const_expr(e)),
- i.lift(|e| folder.fold_const_expr(e)))
- }
- Paren(no_op) => Paren(no_op.lift(|e| folder.fold_const_expr(e))),
- Other(e) => Other(noop_fold_other_const_expr(folder, e)),
- }
-}
-
-#[cfg(feature = "full")]
-fn noop_fold_other_const_expr<F: ?Sized + Folder>(folder: &mut F, e: Expr) -> Expr {
- folder.fold_expr(e)
-}
-
-#[cfg(not(feature = "full"))]
-fn noop_fold_other_const_expr<F: ?Sized + Folder>(_: &mut F,
- e: constant::Other)
- -> constant::Other {
- e
-}
-
-pub fn noop_fold_lit<F: ?Sized + Folder>(_: &mut F, _lit: Lit) -> Lit {
- _lit
-}
-
-pub fn noop_fold_tt<F: ?Sized + Folder>(folder: &mut F, tt: TokenTree) -> TokenTree {
- use TokenTree::*;
- use Token::*;
- match tt {
- Token(token) => {
- Token(match token {
- Literal(lit) => Literal(folder.fold_lit(lit)),
- Ident(ident) => Ident(folder.fold_ident(ident)),
- Lifetime(ident) => Lifetime(folder.fold_ident(ident)),
- x => x,
- })
- }
- Delimited(super::Delimited { delim, tts }) => {
- Delimited(super::Delimited {
- delim: delim,
- tts: tts.lift(|v| noop_fold_tt(folder, v)),
- })
- }
- }
-}
-
-pub fn noop_fold_mac<F: ?Sized + Folder>(folder: &mut F, Mac { path, tts }: Mac) -> Mac {
- Mac {
- path: folder.fold_path(path),
- tts: tts.lift(|tt| noop_fold_tt(folder, tt)),
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_crate<F: ?Sized + Folder>(folder: &mut F,
- Crate { shebang, attrs, items }: Crate)
- -> Crate {
- Crate {
- shebang: shebang,
- attrs: attrs.lift(|a| folder.fold_attribute(a)),
- items: items.lift(|i| folder.fold_item(i)),
- }
-
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_block<F: ?Sized + Folder>(folder: &mut F, block: Block) -> Block {
- Block { stmts: block.stmts.lift(|s| folder.fold_stmt(s)) }
-}
-
-fn noop_fold_vis<F: ?Sized + Folder>(folder: &mut F, vis: Visibility) -> Visibility {
- use Visibility::*;
- match vis {
- Crate => Crate,
- Inherited => Inherited,
- Public => Public,
- Restricted(path) => Restricted(path.lift(|p| folder.fold_path(p))),
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_item<F: ?Sized + Folder>(folder: &mut F,
- Item { ident, vis, attrs, node }: Item)
- -> Item {
- use ItemKind::*;
- Item {
- ident: folder.fold_ident(ident.clone()),
- vis: noop_fold_vis(folder, vis),
- attrs: attrs.lift(|a| folder.fold_attribute(a)),
- node: match node {
- ExternCrate(name) => ExternCrate(name.map(|i| folder.fold_ident(i))),
- Use(view_path) => Use(Box::new(folder.fold_view_path(*view_path))),
- Static(ty, mutability, expr) => {
- Static(Box::new(folder.fold_ty(*ty)),
- mutability,
- expr.lift(|e| folder.fold_expr(e)))
- }
- Const(ty, expr) => {
- Const(ty.lift(|ty| folder.fold_ty(ty)),
- expr.lift(|e| folder.fold_expr(e)))
- }
- Fn(fn_decl, unsafety, constness, abi, generics, block) => {
- Fn(fn_decl.lift(|v| folder.fold_fn_decl(v)),
- unsafety,
- constness,
- abi,
- folder.fold_generics(generics),
- block.lift(|v| folder.fold_block(v)))
- }
- Mod(items) => Mod(items.map(|items| items.lift(|i| folder.fold_item(i)))),
- ForeignMod(super::ForeignMod { abi, items }) => {
- ForeignMod(super::ForeignMod {
- abi: abi,
- items: items.lift(|foreign_item| {
- folder.fold_foreign_item(foreign_item)
- }),
- })
- }
- Ty(ty, generics) => {
- Ty(ty.lift(|ty| folder.fold_ty(ty)),
- folder.fold_generics(generics))
- }
- Enum(variants, generics) => {
- Enum(variants.lift(|v| folder.fold_variant(v)),
- folder.fold_generics(generics))
- }
- Struct(variant_data, generics) => {
- Struct(folder.fold_variant_data(variant_data),
- folder.fold_generics(generics))
- }
- Union(variant_data, generics) => {
- Union(folder.fold_variant_data(variant_data),
- folder.fold_generics(generics))
- }
- Trait(unsafety, generics, typbs, trait_items) => {
- Trait(unsafety,
- folder.fold_generics(generics),
- typbs.lift(|typb| folder.fold_ty_param_bound(typb)),
- trait_items.lift(|ti| folder.fold_trait_item(ti)))
- }
- DefaultImpl(unsafety, path) => DefaultImpl(unsafety, folder.fold_path(path)),
- Impl(unsafety, impl_polarity, generics, path, ty, impl_items) => {
- Impl(unsafety,
- impl_polarity,
- folder.fold_generics(generics),
- path.map(|p| folder.fold_path(p)),
- ty.lift(|ty| folder.fold_ty(ty)),
- impl_items.lift(|i| folder.fold_impl_item(i)))
- }
- Mac(mac) => Mac(folder.fold_mac(mac)),
- },
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_expr<F: ?Sized + Folder>(folder: &mut F, Expr { node, attrs }: Expr) -> Expr {
- use ExprKind::*;
- Expr {
- node: match node {
- ExprKind::Box(e) => ExprKind::Box(e.lift(|e| folder.fold_expr(e))),
- InPlace(place, value) => {
- InPlace(place.lift(|e| folder.fold_expr(e)),
- value.lift(|e| folder.fold_expr(e)))
- }
- Array(array) => Array(array.lift(|e| folder.fold_expr(e))),
- Call(function, args) => {
- Call(function.lift(|e| folder.fold_expr(e)),
- args.lift(|e| folder.fold_expr(e)))
- }
- MethodCall(method, tys, args) => {
- MethodCall(folder.fold_ident(method),
- tys.lift(|t| folder.fold_ty(t)),
- args.lift(|e| folder.fold_expr(e)))
- }
- Tup(args) => Tup(args.lift(|e| folder.fold_expr(e))),
- Binary(bop, lhs, rhs) => {
- Binary(bop,
- lhs.lift(|e| folder.fold_expr(e)),
- rhs.lift(|e| folder.fold_expr(e)))
- }
- Unary(uop, e) => Unary(uop, e.lift(|e| folder.fold_expr(e))),
- Lit(lit) => Lit(folder.fold_lit(lit)),
- Cast(e, ty) => {
- Cast(e.lift(|e| folder.fold_expr(e)),
- ty.lift(|t| folder.fold_ty(t)))
- }
- Type(e, ty) => {
- Type(e.lift(|e| folder.fold_expr(e)),
- ty.lift(|t| folder.fold_ty(t)))
- }
- If(e, if_block, else_block) => {
- If(e.lift(|e| folder.fold_expr(e)),
- folder.fold_block(if_block),
- else_block.map(|v| v.lift(|e| folder.fold_expr(e))))
- }
- IfLet(pat, expr, block, else_block) => {
- IfLet(pat.lift(|p| folder.fold_pat(p)),
- expr.lift(|e| folder.fold_expr(e)),
- folder.fold_block(block),
- else_block.map(|v| v.lift(|e| folder.fold_expr(e))))
- }
- While(e, block, label) => {
- While(e.lift(|e| folder.fold_expr(e)),
- folder.fold_block(block),
- label.map(|i| folder.fold_ident(i)))
- }
- WhileLet(pat, expr, block, label) => {
- WhileLet(pat.lift(|p| folder.fold_pat(p)),
- expr.lift(|e| folder.fold_expr(e)),
- folder.fold_block(block),
- label.map(|i| folder.fold_ident(i)))
- }
- ForLoop(pat, expr, block, label) => {
- ForLoop(pat.lift(|p| folder.fold_pat(p)),
- expr.lift(|e| folder.fold_expr(e)),
- folder.fold_block(block),
- label.map(|i| folder.fold_ident(i)))
- }
- Loop(block, label) => {
- Loop(folder.fold_block(block),
- label.map(|i| folder.fold_ident(i)))
- }
- Match(e, arms) => {
- Match(e.lift(|e| folder.fold_expr(e)),
- arms.lift(|Arm { attrs, pats, guard, body }: Arm| {
- Arm {
- attrs: attrs.lift(|a| folder.fold_attribute(a)),
- pats: pats.lift(|p| folder.fold_pat(p)),
- guard: guard.map(|v| v.lift(|e| folder.fold_expr(e))),
- body: body.lift(|e| folder.fold_expr(e)),
- }
- }))
- }
- Closure(capture_by, fn_decl, expr) => {
- Closure(capture_by,
- fn_decl.lift(|v| folder.fold_fn_decl(v)),
- expr.lift(|e| folder.fold_expr(e)))
- }
- Block(unsafety, block) => Block(unsafety, folder.fold_block(block)),
- Assign(lhs, rhs) => {
- Assign(lhs.lift(|e| folder.fold_expr(e)),
- rhs.lift(|e| folder.fold_expr(e)))
- }
- AssignOp(bop, lhs, rhs) => {
- AssignOp(bop,
- lhs.lift(|e| folder.fold_expr(e)),
- rhs.lift(|e| folder.fold_expr(e)))
- }
- Field(expr, name) => Field(expr.lift(|e| folder.fold_expr(e)), folder.fold_ident(name)),
- TupField(expr, index) => TupField(expr.lift(|e| folder.fold_expr(e)), index),
- Index(expr, index) => {
- Index(expr.lift(|e| folder.fold_expr(e)),
- index.lift(|e| folder.fold_expr(e)))
- }
- Range(lhs, rhs, limits) => {
- Range(lhs.map(|v| v.lift(|e| folder.fold_expr(e))),
- rhs.map(|v| v.lift(|e| folder.fold_expr(e))),
- limits)
- }
- Path(qself, path) => {
- Path(qself.map(|v| noop_fold_qself(folder, v)),
- folder.fold_path(path))
- }
- AddrOf(mutability, expr) => AddrOf(mutability, expr.lift(|e| folder.fold_expr(e))),
- Break(label, expr) => {
- Break(label.map(|i| folder.fold_ident(i)),
- expr.map(|v| v.lift(|e| folder.fold_expr(e))))
- }
- Continue(label) => Continue(label.map(|i| folder.fold_ident(i))),
- Ret(expr) => Ret(expr.map(|v| v.lift(|e| folder.fold_expr(e)))),
- ExprKind::Mac(mac) => ExprKind::Mac(folder.fold_mac(mac)),
- Struct(path, fields, expr) => {
- Struct(folder.fold_path(path),
- fields.lift(|FieldValue { ident, expr, is_shorthand, attrs }: FieldValue| {
- FieldValue {
- ident: folder.fold_ident(ident),
- expr: folder.fold_expr(expr),
- is_shorthand: is_shorthand,
- attrs: attrs.lift(|v| folder.fold_attribute(v)),
- }
- }),
- expr.map(|v| v.lift(|e| folder.fold_expr(e))))
- }
- Repeat(element, number) => {
- Repeat(element.lift(|e| folder.fold_expr(e)),
- number.lift(|e| folder.fold_expr(e)))
- }
- Paren(expr) => Paren(expr.lift(|e| folder.fold_expr(e))),
- Try(expr) => Try(expr.lift(|e| folder.fold_expr(e))),
- },
- attrs: attrs.into_iter().map(|a| folder.fold_attribute(a)).collect(),
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_foreign_item<F: ?Sized + Folder>(folder: &mut F,
- ForeignItem { ident, attrs, node, vis }: ForeignItem)
--> ForeignItem{
- ForeignItem {
- ident: folder.fold_ident(ident),
- attrs: attrs.into_iter().map(|a| folder.fold_attribute(a)).collect(),
- node: match node {
- ForeignItemKind::Fn(fn_dcl, generics) => {
- ForeignItemKind::Fn(fn_dcl.lift(|v| folder.fold_fn_decl(v)),
- folder.fold_generics(generics))
- }
- ForeignItemKind::Static(ty, mutability) => {
- ForeignItemKind::Static(ty.lift(|v| folder.fold_ty(v)), mutability)
- }
- },
- vis: noop_fold_vis(folder, vis),
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_pat<F: ?Sized + Folder>(folder: &mut F, pat: Pat) -> Pat {
- use Pat::*;
- match pat {
- Wild => Wild,
- Ident(binding_mode, ident, pat) => {
- Ident(binding_mode,
- folder.fold_ident(ident),
- pat.map(|p| p.lift(|p| folder.fold_pat(p))))
- }
- Struct(path, field_patterns, dots) => {
- Struct(folder.fold_path(path),
- field_patterns.lift(|FieldPat { ident, pat, is_shorthand, attrs }: FieldPat| {
- FieldPat {
- ident: folder.fold_ident(ident),
- pat: pat.lift(|p| folder.fold_pat(p)),
- is_shorthand: is_shorthand,
- attrs: attrs.lift(|a| folder.fold_attribute(a)),
- }
- }),
- dots)
- }
- TupleStruct(path, pats, len) => {
- TupleStruct(folder.fold_path(path),
- pats.lift(|p| folder.fold_pat(p)),
- len)
- }
- Path(qself, path) => {
- Path(qself.map(|v| noop_fold_qself(folder, v)),
- folder.fold_path(path))
- }
- Tuple(pats, len) => Tuple(pats.lift(|p| folder.fold_pat(p)), len),
- Box(b) => Box(b.lift(|p| folder.fold_pat(p))),
- Ref(b, mutability) => Ref(b.lift(|p| folder.fold_pat(p)), mutability),
- Lit(expr) => Lit(expr.lift(|e| folder.fold_expr(e))),
- Range(l, r) => {
- Range(l.lift(|e| folder.fold_expr(e)),
- r.lift(|e| folder.fold_expr(e)))
- }
- Slice(lefts, pat, rights) => {
- Slice(lefts.lift(|p| folder.fold_pat(p)),
- pat.map(|v| v.lift(|p| folder.fold_pat(p))),
- rights.lift(|p| folder.fold_pat(p)))
- }
- Mac(mac) => Mac(folder.fold_mac(mac)),
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_fn_decl<F: ?Sized + Folder>(folder: &mut F,
- FnDecl { inputs, output, variadic }: FnDecl)
- -> FnDecl {
-
- FnDecl {
- inputs: inputs.lift(|a| {
- use FnArg::*;
- match a {
- SelfRef(lifetime, mutability) => {
- SelfRef(lifetime.map(|v| folder.fold_lifetime(v)), mutability)
- }
- SelfValue(mutability) => SelfValue(mutability),
- Captured(pat, ty) => Captured(folder.fold_pat(pat), folder.fold_ty(ty)),
- Ignored(ty) => Ignored(folder.fold_ty(ty)),
- }
- }),
- output: folder.fold_fn_ret_ty(output),
- variadic: variadic,
- }
-
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_trait_item<F: ?Sized + Folder>(folder: &mut F,
- TraitItem { ident, attrs, node }: TraitItem)
- -> TraitItem {
- use TraitItemKind::*;
- TraitItem {
- ident: folder.fold_ident(ident),
- attrs: attrs.lift(|v| folder.fold_attribute(v)),
- node: match node {
- Const(ty, expr) => Const(folder.fold_ty(ty), expr.map(|v| folder.fold_expr(v))),
- Method(sig, block) => {
- Method(folder.fold_method_sig(sig),
- block.map(|v| folder.fold_block(v)))
- }
- Type(ty_pbs, ty) => {
- Type(ty_pbs.lift(|v| folder.fold_ty_param_bound(v)),
- ty.map(|v| folder.fold_ty(v)))
- }
- Macro(mac) => Macro(folder.fold_mac(mac)),
- },
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_impl_item<F: ?Sized + Folder>(folder: &mut F,
- ImplItem { ident, vis, defaultness, attrs, node }: ImplItem)
--> ImplItem{
- use ImplItemKind::*;
- ImplItem {
- ident: folder.fold_ident(ident),
- vis: noop_fold_vis(folder, vis),
- defaultness: defaultness,
- attrs: attrs.lift(|v| folder.fold_attribute(v)),
- node: match node {
- Const(ty, expr) => Const(folder.fold_ty(ty), folder.fold_expr(expr)),
- Method(sig, block) => Method(folder.fold_method_sig(sig), folder.fold_block(block)),
- Type(ty) => Type(folder.fold_ty(ty)),
- Macro(mac) => Macro(folder.fold_mac(mac)),
- },
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_method_sig<F: ?Sized + Folder>(folder: &mut F, MethodSig{unsafety, constness, abi, decl, generics}:MethodSig) -> MethodSig{
- MethodSig {
- unsafety: unsafety,
- constness: constness,
- abi: abi,
- decl: folder.fold_fn_decl(decl),
- generics: folder.fold_generics(generics),
- }
-
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_stmt<F: ?Sized + Folder>(folder: &mut F, stmt: Stmt) -> Stmt {
- use Stmt::*;
- match stmt {
- Local(local) => Local(local.lift(|l| folder.fold_local(l))),
- Item(item) => Item(item.lift(|v| folder.fold_item(v))),
- Expr(expr) => Expr(expr.lift(|v| folder.fold_expr(v))),
- Semi(expr) => Semi(expr.lift(|v| folder.fold_expr(v))),
- Mac(mac_stmt) => {
- Mac(mac_stmt.lift(|(mac, style, attrs)| {
- (folder.fold_mac(mac),
- style,
- attrs.lift(|a| folder.fold_attribute(a)))
- }))
- }
- }
-
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_local<F: ?Sized + Folder>(folder: &mut F,
- Local { pat, ty, init, attrs }: Local)
- -> Local {
- Local {
- pat: pat.lift(|v| folder.fold_pat(v)),
- ty: ty.map(|v| v.lift(|t| folder.fold_ty(t))),
- init: init.map(|v| v.lift(|e| folder.fold_expr(e))),
- attrs: attrs.lift(|a| folder.fold_attribute(a)),
- }
-}
-
-#[cfg(feature = "full")]
-pub fn noop_fold_view_path<F: ?Sized + Folder>(folder: &mut F, view_path: ViewPath) -> ViewPath {
- use ViewPath::*;
- match view_path {
- Simple(path, ident) => Simple(folder.fold_path(path), ident.map(|i| folder.fold_ident(i))),
- Glob(path) => Glob(folder.fold_path(path)),
- List(path, items) => {
- List(folder.fold_path(path),
- items.lift(|PathListItem { name, rename }: PathListItem| {
- PathListItem {
- name: folder.fold_ident(name),
- rename: rename.map(|i| folder.fold_ident(i)),
- }
- }))
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/generics.rs
+++ /dev/null
@@ -1,513 +0,0 @@
-use super::*;
-
-/// Represents lifetimes and type parameters attached to a declaration
-/// of a function, enum, trait, etc.
-#[derive(Debug, Clone, Eq, PartialEq, Default, Hash)]
-pub struct Generics {
- pub lifetimes: Vec<LifetimeDef>,
- pub ty_params: Vec<TyParam>,
- pub where_clause: WhereClause,
-}
-
-#[cfg(feature = "printing")]
-/// Returned by `Generics::split_for_impl`.
-#[derive(Debug)]
-pub struct ImplGenerics<'a>(&'a Generics);
-
-#[cfg(feature = "printing")]
-/// Returned by `Generics::split_for_impl`.
-#[derive(Debug)]
-pub struct TyGenerics<'a>(&'a Generics);
-
-#[cfg(feature = "printing")]
-/// Returned by `TyGenerics::as_turbofish`.
-#[derive(Debug)]
-pub struct Turbofish<'a>(&'a Generics);
-
-#[cfg(feature = "printing")]
-impl Generics {
- /// Split a type's generics into the pieces required for impl'ing a trait
- /// for that type.
- ///
- /// ```
- /// # extern crate syn;
- /// # #[macro_use]
- /// # extern crate quote;
- /// # fn main() {
- /// # let generics: syn::Generics = Default::default();
- /// # let name = syn::Ident::new("MyType");
- /// let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
- /// quote! {
- /// impl #impl_generics MyTrait for #name #ty_generics #where_clause {
- /// // ...
- /// }
- /// }
- /// # ;
- /// # }
- /// ```
- pub fn split_for_impl(&self) -> (ImplGenerics, TyGenerics, &WhereClause) {
- (ImplGenerics(self), TyGenerics(self), &self.where_clause)
- }
-}
-
-#[cfg(feature = "printing")]
-impl<'a> TyGenerics<'a> {
- /// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`.
- pub fn as_turbofish(&self) -> Turbofish {
- Turbofish(self.0)
- }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
-pub struct Lifetime {
- pub ident: Ident,
-}
-
-impl Lifetime {
- pub fn new<T: Into<Ident>>(t: T) -> Self {
- let id = Ident::new(t);
- if !id.as_ref().starts_with('\'') {
- panic!("lifetime name must start with apostrophe as in \"'a\", \
- got {:?}",
- id.as_ref());
- }
- Lifetime { ident: id }
- }
-}
-
-/// A lifetime definition, e.g. `'a: 'b+'c+'d`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct LifetimeDef {
- pub attrs: Vec<Attribute>,
- pub lifetime: Lifetime,
- pub bounds: Vec<Lifetime>,
-}
-
-impl LifetimeDef {
- pub fn new<T: Into<Ident>>(t: T) -> Self {
- LifetimeDef {
- attrs: Vec::new(),
- lifetime: Lifetime::new(t),
- bounds: Vec::new(),
- }
- }
-}
-
-/// A generic type parameter, e.g. `T: Into<String>`.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct TyParam {
- pub attrs: Vec<Attribute>,
- pub ident: Ident,
- pub bounds: Vec<TyParamBound>,
- pub default: Option<Ty>,
-}
-
-impl From<Ident> for TyParam {
- fn from(ident: Ident) -> Self {
- TyParam {
- attrs: vec![],
- ident: ident,
- bounds: vec![],
- default: None,
- }
- }
-}
-
-/// The AST represents all type param bounds as types.
-/// `typeck::collect::compute_bounds` matches these against
-/// the "special" built-in traits (see `middle::lang_items`) and
-/// detects Copy, Send and Sync.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum TyParamBound {
- Trait(PolyTraitRef, TraitBoundModifier),
- Region(Lifetime),
-}
-
-/// A modifier on a bound, currently this is only used for `?Sized`, where the
-/// modifier is `Maybe`. Negative bounds should also be handled here.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum TraitBoundModifier {
- None,
- Maybe,
-}
-
-/// A `where` clause in a definition
-#[derive(Debug, Clone, Eq, PartialEq, Default, Hash)]
-pub struct WhereClause {
- pub predicates: Vec<WherePredicate>,
-}
-
-impl WhereClause {
- pub fn none() -> Self {
- WhereClause { predicates: Vec::new() }
- }
-}
-
-/// A single predicate in a `where` clause
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum WherePredicate {
- /// A type binding, e.g. `for<'c> Foo: Send+Clone+'c`
- BoundPredicate(WhereBoundPredicate),
- /// A lifetime predicate, e.g. `'a: 'b+'c`
- RegionPredicate(WhereRegionPredicate),
- /// An equality predicate (unsupported)
- EqPredicate(WhereEqPredicate),
-}
-
-/// A type bound.
-///
-/// E.g. `for<'c> Foo: Send+Clone+'c`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct WhereBoundPredicate {
- /// Any lifetimes from a `for` binding
- pub bound_lifetimes: Vec<LifetimeDef>,
- /// The type being bounded
- pub bounded_ty: Ty,
- /// Trait and lifetime bounds (`Clone+Send+'static`)
- pub bounds: Vec<TyParamBound>,
-}
-
-/// A lifetime predicate.
-///
-/// E.g. `'a: 'b+'c`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct WhereRegionPredicate {
- pub lifetime: Lifetime,
- pub bounds: Vec<Lifetime>,
-}
-
-/// An equality predicate (unsupported).
-///
-/// E.g. `T=int`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct WhereEqPredicate {
- pub lhs_ty: Ty,
- pub rhs_ty: Ty,
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use attr::parsing::outer_attr;
- use ident::parsing::ident;
- use ty::parsing::{ty, poly_trait_ref};
-
- named!(pub generics -> Generics, map!(
- alt!(
- do_parse!(
- punct!("<") >>
- lifetimes: separated_list!(punct!(","), lifetime_def) >>
- ty_params: opt_vec!(preceded!(
- cond!(!lifetimes.is_empty(), punct!(",")),
- separated_nonempty_list!(punct!(","), ty_param)
- )) >>
- cond!(!lifetimes.is_empty() || !ty_params.is_empty(), option!(punct!(","))) >>
- punct!(">") >>
- (lifetimes, ty_params)
- )
- |
- epsilon!() => { |_| (Vec::new(), Vec::new()) }
- ),
- |(lifetimes, ty_params)| Generics {
- lifetimes: lifetimes,
- ty_params: ty_params,
- where_clause: Default::default(),
- }
- ));
-
- named!(pub lifetime -> Lifetime, preceded!(
- punct!("'"),
- alt!(
- map!(ident, |id| Lifetime {
- ident: format!("'{}", id).into(),
- })
- |
- map!(keyword!("static"), |_| Lifetime {
- ident: "'static".into(),
- })
- )
- ));
-
- named!(pub lifetime_def -> LifetimeDef, do_parse!(
- attrs: many0!(outer_attr) >>
- life: lifetime >>
- bounds: opt_vec!(preceded!(
- punct!(":"),
- separated_list!(punct!("+"), lifetime)
- )) >>
- (LifetimeDef {
- attrs: attrs,
- lifetime: life,
- bounds: bounds,
- })
- ));
-
- named!(pub bound_lifetimes -> Vec<LifetimeDef>, opt_vec!(do_parse!(
- keyword!("for") >>
- punct!("<") >>
- lifetimes: terminated_list!(punct!(","), lifetime_def) >>
- punct!(">") >>
- (lifetimes)
- )));
-
- named!(ty_param -> TyParam, do_parse!(
- attrs: many0!(outer_attr) >>
- id: ident >>
- bounds: opt_vec!(preceded!(
- punct!(":"),
- separated_nonempty_list!(punct!("+"), ty_param_bound)
- )) >>
- default: option!(preceded!(
- punct!("="),
- ty
- )) >>
- (TyParam {
- attrs: attrs,
- ident: id,
- bounds: bounds,
- default: default,
- })
- ));
-
- named!(pub ty_param_bound -> TyParamBound, alt!(
- preceded!(punct!("?"), poly_trait_ref) => {
- |poly| TyParamBound::Trait(poly, TraitBoundModifier::Maybe)
- }
- |
- lifetime => { TyParamBound::Region }
- |
- poly_trait_ref => {
- |poly| TyParamBound::Trait(poly, TraitBoundModifier::None)
- }
- ));
-
- named!(pub where_clause -> WhereClause, alt!(
- do_parse!(
- keyword!("where") >>
- predicates: separated_nonempty_list!(punct!(","), where_predicate) >>
- option!(punct!(",")) >>
- (WhereClause { predicates: predicates })
- )
- |
- epsilon!() => { |_| Default::default() }
- ));
-
- named!(where_predicate -> WherePredicate, alt!(
- do_parse!(
- ident: lifetime >>
- bounds: opt_vec!(preceded!(
- punct!(":"),
- separated_list!(punct!("+"), lifetime)
- )) >>
- (WherePredicate::RegionPredicate(WhereRegionPredicate {
- lifetime: ident,
- bounds: bounds,
- }))
- )
- |
- do_parse!(
- bound_lifetimes: bound_lifetimes >>
- bounded_ty: ty >>
- punct!(":") >>
- bounds: separated_nonempty_list!(punct!("+"), ty_param_bound) >>
- (WherePredicate::BoundPredicate(WhereBoundPredicate {
- bound_lifetimes: bound_lifetimes,
- bounded_ty: bounded_ty,
- bounds: bounds,
- }))
- )
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use attr::FilterAttrs;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Generics {
- fn to_tokens(&self, tokens: &mut Tokens) {
- let has_lifetimes = !self.lifetimes.is_empty();
- let has_ty_params = !self.ty_params.is_empty();
- if has_lifetimes || has_ty_params {
- tokens.append("<");
- tokens.append_separated(&self.lifetimes, ",");
- if has_lifetimes && has_ty_params {
- tokens.append(",");
- }
- tokens.append_separated(&self.ty_params, ",");
- tokens.append(">");
- }
- }
- }
-
- impl<'a> ToTokens for ImplGenerics<'a> {
- fn to_tokens(&self, tokens: &mut Tokens) {
- let has_lifetimes = !self.0.lifetimes.is_empty();
- let has_ty_params = !self.0.ty_params.is_empty();
- if has_lifetimes || has_ty_params {
- tokens.append("<");
- tokens.append_separated(&self.0.lifetimes, ",");
- // Leave off the type parameter defaults
- for (i, ty_param) in self.0
- .ty_params
- .iter()
- .enumerate() {
- if i > 0 || has_lifetimes {
- tokens.append(",");
- }
- tokens.append_all(ty_param.attrs.outer());
- ty_param.ident.to_tokens(tokens);
- if !ty_param.bounds.is_empty() {
- tokens.append(":");
- tokens.append_separated(&ty_param.bounds, "+");
- }
- }
- tokens.append(">");
- }
- }
- }
-
- impl<'a> ToTokens for TyGenerics<'a> {
- fn to_tokens(&self, tokens: &mut Tokens) {
- let has_lifetimes = !self.0.lifetimes.is_empty();
- let has_ty_params = !self.0.ty_params.is_empty();
- if has_lifetimes || has_ty_params {
- tokens.append("<");
- // Leave off the lifetime bounds and attributes
- let lifetimes = self.0
- .lifetimes
- .iter()
- .map(|ld| &ld.lifetime);
- tokens.append_separated(lifetimes, ",");
- if has_lifetimes && has_ty_params {
- tokens.append(",");
- }
- // Leave off the type parameter bounds, defaults, and attributes
- let ty_params = self.0
- .ty_params
- .iter()
- .map(|tp| &tp.ident);
- tokens.append_separated(ty_params, ",");
- tokens.append(">");
- }
- }
- }
-
- impl<'a> ToTokens for Turbofish<'a> {
- fn to_tokens(&self, tokens: &mut Tokens) {
- let has_lifetimes = !self.0.lifetimes.is_empty();
- let has_ty_params = !self.0.ty_params.is_empty();
- if has_lifetimes || has_ty_params {
- tokens.append("::");
- TyGenerics(self.0).to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for Lifetime {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.ident.to_tokens(tokens);
- }
- }
-
- impl ToTokens for LifetimeDef {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- self.lifetime.to_tokens(tokens);
- if !self.bounds.is_empty() {
- tokens.append(":");
- tokens.append_separated(&self.bounds, "+");
- }
- }
- }
-
- impl ToTokens for TyParam {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- self.ident.to_tokens(tokens);
- if !self.bounds.is_empty() {
- tokens.append(":");
- tokens.append_separated(&self.bounds, "+");
- }
- if let Some(ref default) = self.default {
- tokens.append("=");
- default.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for TyParamBound {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- TyParamBound::Region(ref lifetime) => lifetime.to_tokens(tokens),
- TyParamBound::Trait(ref trait_ref, modifier) => {
- match modifier {
- TraitBoundModifier::None => {}
- TraitBoundModifier::Maybe => tokens.append("?"),
- }
- trait_ref.to_tokens(tokens);
- }
- }
- }
- }
-
- impl ToTokens for WhereClause {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if !self.predicates.is_empty() {
- tokens.append("where");
- tokens.append_separated(&self.predicates, ",");
- }
- }
- }
-
- impl ToTokens for WherePredicate {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- WherePredicate::BoundPredicate(ref predicate) => {
- predicate.to_tokens(tokens);
- }
- WherePredicate::RegionPredicate(ref predicate) => {
- predicate.to_tokens(tokens);
- }
- WherePredicate::EqPredicate(ref predicate) => {
- predicate.to_tokens(tokens);
- }
- }
- }
- }
-
- impl ToTokens for WhereBoundPredicate {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if !self.bound_lifetimes.is_empty() {
- tokens.append("for");
- tokens.append("<");
- tokens.append_separated(&self.bound_lifetimes, ",");
- tokens.append(">");
- }
- self.bounded_ty.to_tokens(tokens);
- if !self.bounds.is_empty() {
- tokens.append(":");
- tokens.append_separated(&self.bounds, "+");
- }
- }
- }
-
- impl ToTokens for WhereRegionPredicate {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.lifetime.to_tokens(tokens);
- if !self.bounds.is_empty() {
- tokens.append(":");
- tokens.append_separated(&self.bounds, "+");
- }
- }
- }
-
- impl ToTokens for WhereEqPredicate {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.lhs_ty.to_tokens(tokens);
- tokens.append("=");
- self.rhs_ty.to_tokens(tokens);
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/ident.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use std::borrow::Cow;
-use std::fmt::{self, Display};
-
-#[derive(Debug, Clone, Eq, Hash, Ord, PartialOrd)]
-pub struct Ident(String);
-
-impl Ident {
- pub fn new<T: Into<Ident>>(t: T) -> Self {
- t.into()
- }
-}
-
-impl<'a> From<&'a str> for Ident {
- fn from(s: &str) -> Self {
- Ident(s.to_owned())
- }
-}
-
-impl<'a> From<Cow<'a, str>> for Ident {
- fn from(s: Cow<'a, str>) -> Self {
- Ident(s.into_owned())
- }
-}
-
-impl From<String> for Ident {
- fn from(s: String) -> Self {
- Ident(s)
- }
-}
-
-impl From<usize> for Ident {
- fn from(u: usize) -> Self {
- Ident(u.to_string())
- }
-}
-
-impl AsRef<str> for Ident {
- fn as_ref(&self) -> &str {
- &self.0
- }
-}
-
-impl Display for Ident {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- self.0.fmt(formatter)
- }
-}
-
-impl<T: ?Sized> PartialEq<T> for Ident
- where T: AsRef<str>
-{
- fn eq(&self, other: &T) -> bool {
- self.0 == other.as_ref()
- }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use synom::IResult;
- use synom::space::skip_whitespace;
- use unicode_xid::UnicodeXID;
-
- pub fn ident(input: &str) -> IResult<&str, Ident> {
- let (rest, id) = match word(input) {
- IResult::Done(rest, id) => (rest, id),
- IResult::Error => return IResult::Error,
- };
-
- match id.as_ref() {
- // From https://doc.rust-lang.org/grammar.html#keywords
- "abstract" | "alignof" | "as" | "become" | "box" | "break" | "const" | "continue" |
- "crate" | "do" | "else" | "enum" | "extern" | "false" | "final" | "fn" | "for" |
- "if" | "impl" | "in" | "let" | "loop" | "macro" | "match" | "mod" | "move" |
- "mut" | "offsetof" | "override" | "priv" | "proc" | "pub" | "pure" | "ref" |
- "return" | "Self" | "self" | "sizeof" | "static" | "struct" | "super" | "trait" |
- "true" | "type" | "typeof" | "unsafe" | "unsized" | "use" | "virtual" | "where" |
- "while" | "yield" => IResult::Error,
- _ => IResult::Done(rest, id),
- }
- }
-
- pub fn word(mut input: &str) -> IResult<&str, Ident> {
- input = skip_whitespace(input);
-
- let mut chars = input.char_indices();
- match chars.next() {
- Some((_, ch)) if UnicodeXID::is_xid_start(ch) || ch == '_' => {}
- _ => return IResult::Error,
- }
-
- for (i, ch) in chars {
- if !UnicodeXID::is_xid_continue(ch) {
- return IResult::Done(&input[i..], input[..i].into());
- }
- }
-
- IResult::Done("", input.into())
- }
-
- #[cfg(feature = "full")]
- pub fn wordlike(mut input: &str) -> IResult<&str, Ident> {
- input = skip_whitespace(input);
-
- for (i, ch) in input.char_indices() {
- if !UnicodeXID::is_xid_start(ch) && !UnicodeXID::is_xid_continue(ch) {
- return if i == 0 {
- IResult::Error
- } else {
- IResult::Done(&input[i..], input[..i].into())
- };
- }
- }
-
- IResult::Done("", input.into())
- }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Ident {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(self.as_ref())
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/item.rs
+++ /dev/null
@@ -1,1477 +0,0 @@
-use super::*;
-
-/// An item
-///
-/// The name might be a dummy name in case of anonymous items
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Item {
- pub ident: Ident,
- pub vis: Visibility,
- pub attrs: Vec<Attribute>,
- pub node: ItemKind,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ItemKind {
- /// An`extern crate` item, with optional original crate name.
- ///
- /// E.g. `extern crate foo` or `extern crate foo_bar as foo`
- ExternCrate(Option<Ident>),
- /// A use declaration (`use` or `pub use`) item.
- ///
- /// E.g. `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`
- Use(Box<ViewPath>),
- /// A static item (`static` or `pub static`).
- ///
- /// E.g. `static FOO: i32 = 42;` or `static FOO: &'static str = "bar";`
- Static(Box<Ty>, Mutability, Box<Expr>),
- /// A constant item (`const` or `pub const`).
- ///
- /// E.g. `const FOO: i32 = 42;`
- Const(Box<Ty>, Box<Expr>),
- /// A function declaration (`fn` or `pub fn`).
- ///
- /// E.g. `fn foo(bar: usize) -> usize { .. }`
- Fn(Box<FnDecl>, Unsafety, Constness, Option<Abi>, Generics, Box<Block>),
- /// A module declaration (`mod` or `pub mod`).
- ///
- /// E.g. `mod foo;` or `mod foo { .. }`
- Mod(Option<Vec<Item>>),
- /// An external module (`extern` or `pub extern`).
- ///
- /// E.g. `extern {}` or `extern "C" {}`
- ForeignMod(ForeignMod),
- /// A type alias (`type` or `pub type`).
- ///
- /// E.g. `type Foo = Bar<u8>;`
- Ty(Box<Ty>, Generics),
- /// An enum definition (`enum` or `pub enum`).
- ///
- /// E.g. `enum Foo<A, B> { C<A>, D<B> }`
- Enum(Vec<Variant>, Generics),
- /// A struct definition (`struct` or `pub struct`).
- ///
- /// E.g. `struct Foo<A> { x: A }`
- Struct(VariantData, Generics),
- /// A union definition (`union` or `pub union`).
- ///
- /// E.g. `union Foo<A, B> { x: A, y: B }`
- Union(VariantData, Generics),
- /// A Trait declaration (`trait` or `pub trait`).
- ///
- /// E.g. `trait Foo { .. }` or `trait Foo<T> { .. }`
- Trait(Unsafety, Generics, Vec<TyParamBound>, Vec<TraitItem>),
- /// Default trait implementation.
- ///
- /// E.g. `impl Trait for .. {}` or `impl<T> Trait<T> for .. {}`
- DefaultImpl(Unsafety, Path),
- /// An implementation.
- ///
- /// E.g. `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`
- Impl(Unsafety,
- ImplPolarity,
- Generics,
- Option<Path>, // (optional) trait this impl implements
- Box<Ty>, // self
- Vec<ImplItem>),
- /// A macro invocation (which includes macro definition).
- ///
- /// E.g. `macro_rules! foo { .. }` or `foo!(..)`
- Mac(Mac),
-}
-
-impl From<DeriveInput> for Item {
- fn from(input: DeriveInput) -> Item {
- Item {
- ident: input.ident,
- vis: input.vis,
- attrs: input.attrs,
- node: match input.body {
- Body::Enum(variants) => ItemKind::Enum(variants, input.generics),
- Body::Struct(variant_data) => ItemKind::Struct(variant_data, input.generics),
- },
- }
- }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ViewPath {
- /// `foo::bar::baz as quux`
- ///
- /// or just
- ///
- /// `foo::bar::baz` (with `as baz` implicitly on the right)
- Simple(Path, Option<Ident>),
-
- /// `foo::bar::*`
- Glob(Path),
-
- /// `foo::bar::{a, b, c}`
- List(Path, Vec<PathListItem>),
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct PathListItem {
- pub name: Ident,
- /// renamed in list, e.g. `use foo::{bar as baz};`
- pub rename: Option<Ident>,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Constness {
- Const,
- NotConst,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Defaultness {
- Default,
- Final,
-}
-
-/// Foreign module declaration.
-///
-/// E.g. `extern { .. }` or `extern "C" { .. }`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ForeignMod {
- pub abi: Abi,
- pub items: Vec<ForeignItem>,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ForeignItem {
- pub ident: Ident,
- pub attrs: Vec<Attribute>,
- pub node: ForeignItemKind,
- pub vis: Visibility,
-}
-
-/// An item within an `extern` block
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ForeignItemKind {
- /// A foreign function
- Fn(Box<FnDecl>, Generics),
- /// A foreign static item (`static ext: u8`)
- Static(Box<Ty>, Mutability),
-}
-
-/// Represents an item declaration within a trait declaration,
-/// possibly including a default implementation. A trait item is
-/// either required (meaning it doesn't have an implementation, just a
-/// signature) or provided (meaning it has a default implementation).
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct TraitItem {
- pub ident: Ident,
- pub attrs: Vec<Attribute>,
- pub node: TraitItemKind,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum TraitItemKind {
- Const(Ty, Option<Expr>),
- Method(MethodSig, Option<Block>),
- Type(Vec<TyParamBound>, Option<Ty>),
- Macro(Mac),
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum ImplPolarity {
- /// `impl Trait for Type`
- Positive,
- /// `impl !Trait for Type`
- Negative,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ImplItem {
- pub ident: Ident,
- pub vis: Visibility,
- pub defaultness: Defaultness,
- pub attrs: Vec<Attribute>,
- pub node: ImplItemKind,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ImplItemKind {
- Const(Ty, Expr),
- Method(MethodSig, Block),
- Type(Ty),
- Macro(Mac),
-}
-
-/// Represents a method's signature in a trait declaration,
-/// or in an implementation.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct MethodSig {
- pub unsafety: Unsafety,
- pub constness: Constness,
- pub abi: Option<Abi>,
- pub decl: FnDecl,
- pub generics: Generics,
-}
-
-/// Header (not the body) of a function declaration.
-///
-/// E.g. `fn foo(bar: baz)`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FnDecl {
- pub inputs: Vec<FnArg>,
- pub output: FunctionRetTy,
- pub variadic: bool,
-}
-
-/// An argument in a function header.
-///
-/// E.g. `bar: usize` as in `fn foo(bar: usize)`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum FnArg {
- SelfRef(Option<Lifetime>, Mutability),
- SelfValue(Mutability),
- Captured(Pat, Ty),
- Ignored(Ty),
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use {Block, DelimToken, FunctionRetTy, Generics, Ident, Mac, Path, TokenTree, VariantData,
- Visibility};
- use attr::parsing::{inner_attr, outer_attr};
- use data::parsing::{struct_like_body, visibility};
- use expr::parsing::{expr, pat, within_block};
- use generics::parsing::{generics, lifetime, ty_param_bound, where_clause};
- use ident::parsing::ident;
- use mac::parsing::delimited;
- use derive::{Body, DeriveInput};
- use derive::parsing::derive_input;
- use ty::parsing::{abi, mutability, path, ty, unsafety};
-
- named!(pub item -> Item, alt!(
- item_extern_crate
- |
- item_use
- |
- item_static
- |
- item_const
- |
- item_fn
- |
- item_mod
- |
- item_foreign_mod
- |
- item_ty
- |
- item_struct_or_enum
- |
- item_union
- |
- item_trait
- |
- item_default_impl
- |
- item_impl
- |
- item_mac
- ));
-
- named!(pub items -> Vec<Item>, many0!(item));
-
- named!(item_mac -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- what: path >>
- punct!("!") >>
- name: option!(ident) >>
- body: delimited >>
- cond!(match body.delim {
- DelimToken::Paren | DelimToken::Bracket => true,
- DelimToken::Brace => false,
- }, punct!(";")) >>
- (Item {
- ident: name.unwrap_or_else(|| Ident::new("")),
- vis: Visibility::Inherited,
- attrs: attrs,
- node: ItemKind::Mac(Mac {
- path: what,
- tts: vec![TokenTree::Delimited(body)],
- }),
- })
- ));
-
- named!(item_extern_crate -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("extern") >>
- keyword!("crate") >>
- id: ident >>
- rename: option!(preceded!(
- keyword!("as"),
- ident
- )) >>
- punct!(";") >>
- ({
- let (name, original_name) = match rename {
- Some(rename) => (rename, Some(id)),
- None => (id, None),
- };
- Item {
- ident: name,
- vis: vis,
- attrs: attrs,
- node: ItemKind::ExternCrate(original_name),
- }
- })
- ));
-
- named!(item_use -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("use") >>
- what: view_path >>
- punct!(";") >>
- (Item {
- ident: "".into(),
- vis: vis,
- attrs: attrs,
- node: ItemKind::Use(Box::new(what)),
- })
- ));
-
- named!(view_path -> ViewPath, alt!(
- view_path_glob
- |
- view_path_list
- |
- view_path_list_root
- |
- view_path_simple // must be last
- ));
-
-
- named!(view_path_simple -> ViewPath, do_parse!(
- path: path >>
- rename: option!(preceded!(keyword!("as"), ident)) >>
- (ViewPath::Simple(path, rename))
- ));
-
- named!(view_path_glob -> ViewPath, do_parse!(
- path: path >>
- punct!("::") >>
- punct!("*") >>
- (ViewPath::Glob(path))
- ));
-
- named!(view_path_list -> ViewPath, do_parse!(
- path: path >>
- punct!("::") >>
- punct!("{") >>
- items: terminated_list!(punct!(","), path_list_item) >>
- punct!("}") >>
- (ViewPath::List(path, items))
- ));
-
- named!(view_path_list_root -> ViewPath, do_parse!(
- global: option!(punct!("::")) >>
- punct!("{") >>
- items: terminated_list!(punct!(","), path_list_item) >>
- punct!("}") >>
- (ViewPath::List(Path {
- global: global.is_some(),
- segments: Vec::new(),
- }, items))
- ));
-
- named!(path_list_item -> PathListItem, do_parse!(
- name: alt!(
- ident
- |
- map!(keyword!("self"), Into::into)
- ) >>
- rename: option!(preceded!(keyword!("as"), ident)) >>
- (PathListItem {
- name: name,
- rename: rename,
- })
- ));
-
- named!(item_static -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("static") >>
- mutability: mutability >>
- id: ident >>
- punct!(":") >>
- ty: ty >>
- punct!("=") >>
- value: expr >>
- punct!(";") >>
- (Item {
- ident: id,
- vis: vis,
- attrs: attrs,
- node: ItemKind::Static(Box::new(ty), mutability, Box::new(value)),
- })
- ));
-
- named!(item_const -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("const") >>
- id: ident >>
- punct!(":") >>
- ty: ty >>
- punct!("=") >>
- value: expr >>
- punct!(";") >>
- (Item {
- ident: id,
- vis: vis,
- attrs: attrs,
- node: ItemKind::Const(Box::new(ty), Box::new(value)),
- })
- ));
-
- named!(item_fn -> Item, do_parse!(
- outer_attrs: many0!(outer_attr) >>
- vis: visibility >>
- constness: constness >>
- unsafety: unsafety >>
- abi: option!(abi) >>
- keyword!("fn") >>
- name: ident >>
- generics: generics >>
- punct!("(") >>
- inputs: terminated_list!(punct!(","), fn_arg) >>
- punct!(")") >>
- ret: option!(preceded!(punct!("->"), ty)) >>
- where_clause: where_clause >>
- punct!("{") >>
- inner_attrs: many0!(inner_attr) >>
- stmts: within_block >>
- punct!("}") >>
- (Item {
- ident: name,
- vis: vis,
- attrs: {
- let mut attrs = outer_attrs;
- attrs.extend(inner_attrs);
- attrs
- },
- node: ItemKind::Fn(
- Box::new(FnDecl {
- inputs: inputs,
- output: ret.map(FunctionRetTy::Ty).unwrap_or(FunctionRetTy::Default),
- variadic: false,
- }),
- unsafety,
- constness,
- abi,
- Generics {
- where_clause: where_clause,
- .. generics
- },
- Box::new(Block {
- stmts: stmts,
- }),
- ),
- })
- ));
-
- named!(fn_arg -> FnArg, alt!(
- do_parse!(
- punct!("&") >>
- lt: option!(lifetime) >>
- mutability: mutability >>
- keyword!("self") >>
- not!(punct!(":")) >>
- (FnArg::SelfRef(lt, mutability))
- )
- |
- do_parse!(
- mutability: mutability >>
- keyword!("self") >>
- not!(punct!(":")) >>
- (FnArg::SelfValue(mutability))
- )
- |
- do_parse!(
- pat: pat >>
- punct!(":") >>
- ty: ty >>
- (FnArg::Captured(pat, ty))
- )
- |
- ty => { FnArg::Ignored }
- ));
-
- named!(item_mod -> Item, do_parse!(
- outer_attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("mod") >>
- id: ident >>
- content: alt!(
- punct!(";") => { |_| None }
- |
- delimited!(
- punct!("{"),
- tuple!(
- many0!(inner_attr),
- items
- ),
- punct!("}")
- ) => { Some }
- ) >>
- (match content {
- Some((inner_attrs, items)) => Item {
- ident: id,
- vis: vis,
- attrs: {
- let mut attrs = outer_attrs;
- attrs.extend(inner_attrs);
- attrs
- },
- node: ItemKind::Mod(Some(items)),
- },
- None => Item {
- ident: id,
- vis: vis,
- attrs: outer_attrs,
- node: ItemKind::Mod(None),
- },
- })
- ));
-
- named!(item_foreign_mod -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- abi: abi >>
- punct!("{") >>
- items: many0!(foreign_item) >>
- punct!("}") >>
- (Item {
- ident: "".into(),
- vis: Visibility::Inherited,
- attrs: attrs,
- node: ItemKind::ForeignMod(ForeignMod {
- abi: abi,
- items: items,
- }),
- })
- ));
-
- named!(foreign_item -> ForeignItem, alt!(
- foreign_fn
- |
- foreign_static
- ));
-
- named!(foreign_fn -> ForeignItem, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("fn") >>
- name: ident >>
- generics: generics >>
- punct!("(") >>
- inputs: separated_list!(punct!(","), fn_arg) >>
- trailing_comma: option!(punct!(",")) >>
- variadic: option!(cond_reduce!(trailing_comma.is_some(), punct!("..."))) >>
- punct!(")") >>
- ret: option!(preceded!(punct!("->"), ty)) >>
- where_clause: where_clause >>
- punct!(";") >>
- (ForeignItem {
- ident: name,
- attrs: attrs,
- node: ForeignItemKind::Fn(
- Box::new(FnDecl {
- inputs: inputs,
- output: ret.map(FunctionRetTy::Ty).unwrap_or(FunctionRetTy::Default),
- variadic: variadic.is_some(),
- }),
- Generics {
- where_clause: where_clause,
- .. generics
- },
- ),
- vis: vis,
- })
- ));
-
- named!(foreign_static -> ForeignItem, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("static") >>
- mutability: mutability >>
- id: ident >>
- punct!(":") >>
- ty: ty >>
- punct!(";") >>
- (ForeignItem {
- ident: id,
- attrs: attrs,
- node: ForeignItemKind::Static(Box::new(ty), mutability),
- vis: vis,
- })
- ));
-
- named!(item_ty -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("type") >>
- id: ident >>
- generics: generics >>
- where_clause: where_clause >>
- punct!("=") >>
- ty: ty >>
- punct!(";") >>
- (Item {
- ident: id,
- vis: vis,
- attrs: attrs,
- node: ItemKind::Ty(
- Box::new(ty),
- Generics {
- where_clause: where_clause,
- ..generics
- },
- ),
- })
- ));
-
- named!(item_struct_or_enum -> Item, map!(
- derive_input,
- |def: DeriveInput| Item {
- ident: def.ident,
- vis: def.vis,
- attrs: def.attrs,
- node: match def.body {
- Body::Enum(variants) => {
- ItemKind::Enum(variants, def.generics)
- }
- Body::Struct(variant_data) => {
- ItemKind::Struct(variant_data, def.generics)
- }
- }
- }
- ));
-
- named!(item_union -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- keyword!("union") >>
- id: ident >>
- generics: generics >>
- where_clause: where_clause >>
- fields: struct_like_body >>
- (Item {
- ident: id,
- vis: vis,
- attrs: attrs,
- node: ItemKind::Union(
- VariantData::Struct(fields),
- Generics {
- where_clause: where_clause,
- .. generics
- },
- ),
- })
- ));
-
- named!(item_trait -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- unsafety: unsafety >>
- keyword!("trait") >>
- id: ident >>
- generics: generics >>
- bounds: opt_vec!(preceded!(
- punct!(":"),
- separated_nonempty_list!(punct!("+"), ty_param_bound)
- )) >>
- where_clause: where_clause >>
- punct!("{") >>
- body: many0!(trait_item) >>
- punct!("}") >>
- (Item {
- ident: id,
- vis: vis,
- attrs: attrs,
- node: ItemKind::Trait(
- unsafety,
- Generics {
- where_clause: where_clause,
- .. generics
- },
- bounds,
- body,
- ),
- })
- ));
-
- named!(item_default_impl -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- unsafety: unsafety >>
- keyword!("impl") >>
- path: path >>
- keyword!("for") >>
- punct!("..") >>
- punct!("{") >>
- punct!("}") >>
- (Item {
- ident: "".into(),
- vis: Visibility::Inherited,
- attrs: attrs,
- node: ItemKind::DefaultImpl(unsafety, path),
- })
- ));
-
- named!(trait_item -> TraitItem, alt!(
- trait_item_const
- |
- trait_item_method
- |
- trait_item_type
- |
- trait_item_mac
- ));
-
- named!(trait_item_const -> TraitItem, do_parse!(
- attrs: many0!(outer_attr) >>
- keyword!("const") >>
- id: ident >>
- punct!(":") >>
- ty: ty >>
- value: option!(preceded!(punct!("="), expr)) >>
- punct!(";") >>
- (TraitItem {
- ident: id,
- attrs: attrs,
- node: TraitItemKind::Const(ty, value),
- })
- ));
-
- named!(trait_item_method -> TraitItem, do_parse!(
- outer_attrs: many0!(outer_attr) >>
- constness: constness >>
- unsafety: unsafety >>
- abi: option!(abi) >>
- keyword!("fn") >>
- name: ident >>
- generics: generics >>
- punct!("(") >>
- inputs: terminated_list!(punct!(","), fn_arg) >>
- punct!(")") >>
- ret: option!(preceded!(punct!("->"), ty)) >>
- where_clause: where_clause >>
- body: option!(delimited!(
- punct!("{"),
- tuple!(many0!(inner_attr), within_block),
- punct!("}")
- )) >>
- cond!(body.is_none(), punct!(";")) >>
- ({
- let (inner_attrs, stmts) = match body {
- Some((inner_attrs, stmts)) => (inner_attrs, Some(stmts)),
- None => (Vec::new(), None),
- };
- TraitItem {
- ident: name,
- attrs: {
- let mut attrs = outer_attrs;
- attrs.extend(inner_attrs);
- attrs
- },
- node: TraitItemKind::Method(
- MethodSig {
- unsafety: unsafety,
- constness: constness,
- abi: abi,
- decl: FnDecl {
- inputs: inputs,
- output: ret.map(FunctionRetTy::Ty).unwrap_or(FunctionRetTy::Default),
- variadic: false,
- },
- generics: Generics {
- where_clause: where_clause,
- .. generics
- },
- },
- stmts.map(|stmts| Block { stmts: stmts }),
- ),
- }
- })
- ));
-
- named!(trait_item_type -> TraitItem, do_parse!(
- attrs: many0!(outer_attr) >>
- keyword!("type") >>
- id: ident >>
- bounds: opt_vec!(preceded!(
- punct!(":"),
- separated_nonempty_list!(punct!("+"), ty_param_bound)
- )) >>
- default: option!(preceded!(punct!("="), ty)) >>
- punct!(";") >>
- (TraitItem {
- ident: id,
- attrs: attrs,
- node: TraitItemKind::Type(bounds, default),
- })
- ));
-
- named!(trait_item_mac -> TraitItem, do_parse!(
- attrs: many0!(outer_attr) >>
- what: path >>
- punct!("!") >>
- body: delimited >>
- cond!(match body.delim {
- DelimToken::Paren | DelimToken::Bracket => true,
- DelimToken::Brace => false,
- }, punct!(";")) >>
- (TraitItem {
- ident: Ident::new(""),
- attrs: attrs,
- node: TraitItemKind::Macro(Mac {
- path: what,
- tts: vec![TokenTree::Delimited(body)],
- }),
- })
- ));
-
- named!(item_impl -> Item, do_parse!(
- attrs: many0!(outer_attr) >>
- unsafety: unsafety >>
- keyword!("impl") >>
- generics: generics >>
- polarity_path: alt!(
- do_parse!(
- polarity: impl_polarity >>
- path: path >>
- keyword!("for") >>
- (polarity, Some(path))
- )
- |
- epsilon!() => { |_| (ImplPolarity::Positive, None) }
- ) >>
- self_ty: ty >>
- where_clause: where_clause >>
- punct!("{") >>
- body: many0!(impl_item) >>
- punct!("}") >>
- (Item {
- ident: "".into(),
- vis: Visibility::Inherited,
- attrs: attrs,
- node: ItemKind::Impl(
- unsafety,
- polarity_path.0,
- Generics {
- where_clause: where_clause,
- .. generics
- },
- polarity_path.1,
- Box::new(self_ty),
- body,
- ),
- })
- ));
-
- named!(impl_item -> ImplItem, alt!(
- impl_item_const
- |
- impl_item_method
- |
- impl_item_type
- |
- impl_item_macro
- ));
-
- named!(impl_item_const -> ImplItem, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- defaultness: defaultness >>
- keyword!("const") >>
- id: ident >>
- punct!(":") >>
- ty: ty >>
- punct!("=") >>
- value: expr >>
- punct!(";") >>
- (ImplItem {
- ident: id,
- vis: vis,
- defaultness: defaultness,
- attrs: attrs,
- node: ImplItemKind::Const(ty, value),
- })
- ));
-
- named!(impl_item_method -> ImplItem, do_parse!(
- outer_attrs: many0!(outer_attr) >>
- vis: visibility >>
- defaultness: defaultness >>
- constness: constness >>
- unsafety: unsafety >>
- abi: option!(abi) >>
- keyword!("fn") >>
- name: ident >>
- generics: generics >>
- punct!("(") >>
- inputs: terminated_list!(punct!(","), fn_arg) >>
- punct!(")") >>
- ret: option!(preceded!(punct!("->"), ty)) >>
- where_clause: where_clause >>
- punct!("{") >>
- inner_attrs: many0!(inner_attr) >>
- stmts: within_block >>
- punct!("}") >>
- (ImplItem {
- ident: name,
- vis: vis,
- defaultness: defaultness,
- attrs: {
- let mut attrs = outer_attrs;
- attrs.extend(inner_attrs);
- attrs
- },
- node: ImplItemKind::Method(
- MethodSig {
- unsafety: unsafety,
- constness: constness,
- abi: abi,
- decl: FnDecl {
- inputs: inputs,
- output: ret.map(FunctionRetTy::Ty).unwrap_or(FunctionRetTy::Default),
- variadic: false,
- },
- generics: Generics {
- where_clause: where_clause,
- .. generics
- },
- },
- Block {
- stmts: stmts,
- },
- ),
- })
- ));
-
- named!(impl_item_type -> ImplItem, do_parse!(
- attrs: many0!(outer_attr) >>
- vis: visibility >>
- defaultness: defaultness >>
- keyword!("type") >>
- id: ident >>
- punct!("=") >>
- ty: ty >>
- punct!(";") >>
- (ImplItem {
- ident: id,
- vis: vis,
- defaultness: defaultness,
- attrs: attrs,
- node: ImplItemKind::Type(ty),
- })
- ));
-
- named!(impl_item_macro -> ImplItem, do_parse!(
- attrs: many0!(outer_attr) >>
- what: path >>
- punct!("!") >>
- body: delimited >>
- cond!(match body.delim {
- DelimToken::Paren | DelimToken::Bracket => true,
- DelimToken::Brace => false,
- }, punct!(";")) >>
- (ImplItem {
- ident: Ident::new(""),
- vis: Visibility::Inherited,
- defaultness: Defaultness::Final,
- attrs: attrs,
- node: ImplItemKind::Macro(Mac {
- path: what,
- tts: vec![TokenTree::Delimited(body)],
- }),
- })
- ));
-
- named!(impl_polarity -> ImplPolarity, alt!(
- punct!("!") => { |_| ImplPolarity::Negative }
- |
- epsilon!() => { |_| ImplPolarity::Positive }
- ));
-
- named!(constness -> Constness, alt!(
- keyword!("const") => { |_| Constness::Const }
- |
- epsilon!() => { |_| Constness::NotConst }
- ));
-
- named!(defaultness -> Defaultness, alt!(
- keyword!("default") => { |_| Defaultness::Default }
- |
- epsilon!() => { |_| Defaultness::Final }
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use {Delimited, DelimToken, FunctionRetTy, TokenTree};
- use attr::FilterAttrs;
- use data::VariantData;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Item {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- match self.node {
- ItemKind::ExternCrate(ref original) => {
- self.vis.to_tokens(tokens);
- tokens.append("extern");
- tokens.append("crate");
- if let Some(ref original) = *original {
- original.to_tokens(tokens);
- tokens.append("as");
- }
- self.ident.to_tokens(tokens);
- tokens.append(";");
- }
- ItemKind::Use(ref view_path) => {
- self.vis.to_tokens(tokens);
- tokens.append("use");
- view_path.to_tokens(tokens);
- tokens.append(";");
- }
- ItemKind::Static(ref ty, ref mutability, ref expr) => {
- self.vis.to_tokens(tokens);
- tokens.append("static");
- mutability.to_tokens(tokens);
- self.ident.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- tokens.append("=");
- expr.to_tokens(tokens);
- tokens.append(";");
- }
- ItemKind::Const(ref ty, ref expr) => {
- self.vis.to_tokens(tokens);
- tokens.append("const");
- self.ident.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- tokens.append("=");
- expr.to_tokens(tokens);
- tokens.append(";");
- }
- ItemKind::Fn(ref decl, unsafety, constness, ref abi, ref generics, ref block) => {
- self.vis.to_tokens(tokens);
- constness.to_tokens(tokens);
- unsafety.to_tokens(tokens);
- abi.to_tokens(tokens);
- tokens.append("fn");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(&decl.inputs, ",");
- tokens.append(")");
- if let FunctionRetTy::Ty(ref ty) = decl.output {
- tokens.append("->");
- ty.to_tokens(tokens);
- }
- generics.where_clause.to_tokens(tokens);
- tokens.append("{");
- tokens.append_all(self.attrs.inner());
- tokens.append_all(&block.stmts);
- tokens.append("}");
- }
- ItemKind::Mod(ref items) => {
- self.vis.to_tokens(tokens);
- tokens.append("mod");
- self.ident.to_tokens(tokens);
- match *items {
- Some(ref items) => {
- tokens.append("{");
- tokens.append_all(self.attrs.inner());
- tokens.append_all(items);
- tokens.append("}");
- }
- None => tokens.append(";"),
- }
- }
- ItemKind::ForeignMod(ref foreign_mod) => {
- self.vis.to_tokens(tokens);
- foreign_mod.abi.to_tokens(tokens);
- tokens.append("{");
- tokens.append_all(&foreign_mod.items);
- tokens.append("}");
- }
- ItemKind::Ty(ref ty, ref generics) => {
- self.vis.to_tokens(tokens);
- tokens.append("type");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- generics.where_clause.to_tokens(tokens);
- tokens.append("=");
- ty.to_tokens(tokens);
- tokens.append(";");
- }
- ItemKind::Enum(ref variants, ref generics) => {
- self.vis.to_tokens(tokens);
- tokens.append("enum");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- generics.where_clause.to_tokens(tokens);
- tokens.append("{");
- for variant in variants {
- variant.to_tokens(tokens);
- tokens.append(",");
- }
- tokens.append("}");
- }
- ItemKind::Struct(ref variant_data, ref generics) => {
- self.vis.to_tokens(tokens);
- tokens.append("struct");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- match *variant_data {
- VariantData::Struct(_) => {
- generics.where_clause.to_tokens(tokens);
- variant_data.to_tokens(tokens);
- // no semicolon
- }
- VariantData::Tuple(_) => {
- variant_data.to_tokens(tokens);
- generics.where_clause.to_tokens(tokens);
- tokens.append(";");
- }
- VariantData::Unit => {
- generics.where_clause.to_tokens(tokens);
- tokens.append(";");
- }
- }
- }
- ItemKind::Union(ref variant_data, ref generics) => {
- self.vis.to_tokens(tokens);
- tokens.append("union");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- generics.where_clause.to_tokens(tokens);
- variant_data.to_tokens(tokens);
- }
- ItemKind::Trait(unsafety, ref generics, ref bound, ref items) => {
- self.vis.to_tokens(tokens);
- unsafety.to_tokens(tokens);
- tokens.append("trait");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- if !bound.is_empty() {
- tokens.append(":");
- tokens.append_separated(bound, "+");
- }
- generics.where_clause.to_tokens(tokens);
- tokens.append("{");
- tokens.append_all(items);
- tokens.append("}");
- }
- ItemKind::DefaultImpl(unsafety, ref path) => {
- unsafety.to_tokens(tokens);
- tokens.append("impl");
- path.to_tokens(tokens);
- tokens.append("for");
- tokens.append("..");
- tokens.append("{");
- tokens.append("}");
- }
- ItemKind::Impl(unsafety, polarity, ref generics, ref path, ref ty, ref items) => {
- unsafety.to_tokens(tokens);
- tokens.append("impl");
- generics.to_tokens(tokens);
- if let Some(ref path) = *path {
- polarity.to_tokens(tokens);
- path.to_tokens(tokens);
- tokens.append("for");
- }
- ty.to_tokens(tokens);
- generics.where_clause.to_tokens(tokens);
- tokens.append("{");
- tokens.append_all(items);
- tokens.append("}");
- }
- ItemKind::Mac(ref mac) => {
- mac.path.to_tokens(tokens);
- tokens.append("!");
- self.ident.to_tokens(tokens);
- for tt in &mac.tts {
- tt.to_tokens(tokens);
- }
- match mac.tts.last() {
- Some(&TokenTree::Delimited(Delimited { delim: DelimToken::Brace, .. })) => {
- // no semicolon
- }
- _ => tokens.append(";"),
- }
- }
- }
- }
- }
-
- impl ToTokens for ViewPath {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- ViewPath::Simple(ref path, ref rename) => {
- path.to_tokens(tokens);
- if let Some(ref rename) = *rename {
- tokens.append("as");
- rename.to_tokens(tokens);
- }
- }
- ViewPath::Glob(ref path) => {
- path.to_tokens(tokens);
- tokens.append("::");
- tokens.append("*");
- }
- ViewPath::List(ref path, ref items) => {
- path.to_tokens(tokens);
- if path.global || !path.segments.is_empty() {
- tokens.append("::");
- }
- tokens.append("{");
- tokens.append_separated(items, ",");
- tokens.append("}");
- }
- }
- }
- }
-
- impl ToTokens for PathListItem {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.name.to_tokens(tokens);
- if let Some(ref rename) = self.rename {
- tokens.append("as");
- rename.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for TraitItem {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- match self.node {
- TraitItemKind::Const(ref ty, ref expr) => {
- tokens.append("const");
- self.ident.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- if let Some(ref expr) = *expr {
- tokens.append("=");
- expr.to_tokens(tokens);
- }
- tokens.append(";");
- }
- TraitItemKind::Method(ref sig, ref block) => {
- sig.constness.to_tokens(tokens);
- sig.unsafety.to_tokens(tokens);
- sig.abi.to_tokens(tokens);
- tokens.append("fn");
- self.ident.to_tokens(tokens);
- sig.generics.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(&sig.decl.inputs, ",");
- tokens.append(")");
- if let FunctionRetTy::Ty(ref ty) = sig.decl.output {
- tokens.append("->");
- ty.to_tokens(tokens);
- }
- sig.generics.where_clause.to_tokens(tokens);
- match *block {
- Some(ref block) => {
- tokens.append("{");
- tokens.append_all(self.attrs.inner());
- tokens.append_all(&block.stmts);
- tokens.append("}");
- }
- None => tokens.append(";"),
- }
- }
- TraitItemKind::Type(ref bound, ref default) => {
- tokens.append("type");
- self.ident.to_tokens(tokens);
- if !bound.is_empty() {
- tokens.append(":");
- tokens.append_separated(bound, "+");
- }
- if let Some(ref default) = *default {
- tokens.append("=");
- default.to_tokens(tokens);
- }
- tokens.append(";");
- }
- TraitItemKind::Macro(ref mac) => {
- mac.to_tokens(tokens);
- match mac.tts.last() {
- Some(&TokenTree::Delimited(Delimited { delim: DelimToken::Brace, .. })) => {
- // no semicolon
- }
- _ => tokens.append(";"),
- }
- }
- }
- }
- }
-
- impl ToTokens for ImplItem {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- match self.node {
- ImplItemKind::Const(ref ty, ref expr) => {
- self.vis.to_tokens(tokens);
- self.defaultness.to_tokens(tokens);
- tokens.append("const");
- self.ident.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- tokens.append("=");
- expr.to_tokens(tokens);
- tokens.append(";");
- }
- ImplItemKind::Method(ref sig, ref block) => {
- self.vis.to_tokens(tokens);
- self.defaultness.to_tokens(tokens);
- sig.constness.to_tokens(tokens);
- sig.unsafety.to_tokens(tokens);
- sig.abi.to_tokens(tokens);
- tokens.append("fn");
- self.ident.to_tokens(tokens);
- sig.generics.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(&sig.decl.inputs, ",");
- tokens.append(")");
- if let FunctionRetTy::Ty(ref ty) = sig.decl.output {
- tokens.append("->");
- ty.to_tokens(tokens);
- }
- sig.generics.where_clause.to_tokens(tokens);
- tokens.append("{");
- tokens.append_all(self.attrs.inner());
- tokens.append_all(&block.stmts);
- tokens.append("}");
- }
- ImplItemKind::Type(ref ty) => {
- self.vis.to_tokens(tokens);
- self.defaultness.to_tokens(tokens);
- tokens.append("type");
- self.ident.to_tokens(tokens);
- tokens.append("=");
- ty.to_tokens(tokens);
- tokens.append(";");
- }
- ImplItemKind::Macro(ref mac) => {
- mac.to_tokens(tokens);
- match mac.tts.last() {
- Some(&TokenTree::Delimited(Delimited { delim: DelimToken::Brace, .. })) => {
- // no semicolon
- }
- _ => tokens.append(";"),
- }
- }
- }
- }
- }
-
- impl ToTokens for ForeignItem {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append_all(self.attrs.outer());
- match self.node {
- ForeignItemKind::Fn(ref decl, ref generics) => {
- self.vis.to_tokens(tokens);
- tokens.append("fn");
- self.ident.to_tokens(tokens);
- generics.to_tokens(tokens);
- tokens.append("(");
- tokens.append_separated(&decl.inputs, ",");
- if decl.variadic {
- if !decl.inputs.is_empty() {
- tokens.append(",");
- }
- tokens.append("...");
- }
- tokens.append(")");
- if let FunctionRetTy::Ty(ref ty) = decl.output {
- tokens.append("->");
- ty.to_tokens(tokens);
- }
- generics.where_clause.to_tokens(tokens);
- tokens.append(";");
- }
- ForeignItemKind::Static(ref ty, mutability) => {
- self.vis.to_tokens(tokens);
- tokens.append("static");
- mutability.to_tokens(tokens);
- self.ident.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- tokens.append(";");
- }
- }
- }
- }
-
- impl ToTokens for FnArg {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- FnArg::SelfRef(ref lifetime, mutability) => {
- tokens.append("&");
- lifetime.to_tokens(tokens);
- mutability.to_tokens(tokens);
- tokens.append("self");
- }
- FnArg::SelfValue(mutability) => {
- mutability.to_tokens(tokens);
- tokens.append("self");
- }
- FnArg::Captured(ref pat, ref ty) => {
- pat.to_tokens(tokens);
- tokens.append(":");
- ty.to_tokens(tokens);
- }
- FnArg::Ignored(ref ty) => {
- ty.to_tokens(tokens);
- }
- }
- }
- }
-
- impl ToTokens for Constness {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Constness::Const => tokens.append("const"),
- Constness::NotConst => {
- // nothing
- }
- }
- }
- }
-
- impl ToTokens for Defaultness {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Defaultness::Default => tokens.append("default"),
- Defaultness::Final => {
- // nothing
- }
- }
- }
- }
-
- impl ToTokens for ImplPolarity {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- ImplPolarity::Negative => tokens.append("!"),
- ImplPolarity::Positive => {
- // nothing
- }
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/krate.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use super::*;
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Crate {
- pub shebang: Option<String>,
- pub attrs: Vec<Attribute>,
- pub items: Vec<Item>,
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use attr::parsing::inner_attr;
- use item::parsing::items;
-
- named!(pub krate -> Crate, do_parse!(
- option!(byte_order_mark) >>
- shebang: option!(shebang) >>
- attrs: many0!(inner_attr) >>
- items: items >>
- (Crate {
- shebang: shebang,
- attrs: attrs,
- items: items,
- })
- ));
-
- named!(byte_order_mark -> &str, tag!("\u{feff}"));
-
- named!(shebang -> String, do_parse!(
- tag!("#!") >>
- not!(tag!("[")) >>
- content: take_until!("\n") >>
- (format!("#!{}", content))
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use attr::FilterAttrs;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Crate {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if let Some(ref shebang) = self.shebang {
- tokens.append(&format!("{}\n", shebang));
- }
- for attr in self.attrs.inner() {
- attr.to_tokens(tokens);
- }
- for item in &self.items {
- item.to_tokens(tokens);
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/lib.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-#![doc(html_root_url = "https://dtolnay.github.io/syn")]
-
-#![cfg_attr(feature = "cargo-clippy", allow(large_enum_variant))]
-
-#[cfg(feature = "printing")]
-extern crate quote;
-
-#[cfg(feature = "parsing")]
-extern crate unicode_xid;
-
-#[cfg(feature = "parsing")]
-#[macro_use]
-extern crate synom;
-
-#[cfg(feature = "aster")]
-pub mod aster;
-
-mod attr;
-pub use attr::{Attribute, AttrStyle, MetaItem, NestedMetaItem};
-
-mod constant;
-pub use constant::ConstExpr;
-
-mod data;
-pub use data::{Field, Variant, VariantData, Visibility};
-
-#[cfg(feature = "parsing")]
-mod escape;
-
-#[cfg(feature = "full")]
-mod expr;
-#[cfg(feature = "full")]
-pub use expr::{Arm, BindingMode, Block, CaptureBy, Expr, ExprKind, FieldPat, FieldValue, Local,
- MacStmtStyle, Pat, RangeLimits, Stmt};
-
-mod generics;
-pub use generics::{Generics, Lifetime, LifetimeDef, TraitBoundModifier, TyParam, TyParamBound,
- WhereBoundPredicate, WhereClause, WhereEqPredicate, WherePredicate,
- WhereRegionPredicate};
-#[cfg(feature = "printing")]
-pub use generics::{ImplGenerics, Turbofish, TyGenerics};
-
-mod ident;
-pub use ident::Ident;
-
-#[cfg(feature = "full")]
-mod item;
-#[cfg(feature = "full")]
-pub use item::{Constness, Defaultness, FnArg, FnDecl, ForeignItemKind, ForeignItem, ForeignMod,
- ImplItem, ImplItemKind, ImplPolarity, Item, ItemKind, MethodSig, PathListItem,
- TraitItem, TraitItemKind, ViewPath};
-
-#[cfg(feature = "full")]
-mod krate;
-#[cfg(feature = "full")]
-pub use krate::Crate;
-
-mod lit;
-pub use lit::{FloatTy, IntTy, Lit, StrStyle};
-#[cfg(feature = "parsing")]
-pub use lit::{ByteStrLit, FloatLit, IntLit, StrLit};
-
-mod mac;
-pub use mac::{BinOpToken, DelimToken, Delimited, Mac, Token, TokenTree};
-
-mod derive;
-pub use derive::{Body, DeriveInput};
-// Deprecated. Use `DeriveInput` instead.
-#[doc(hidden)]
-pub type MacroInput = DeriveInput;
-
-mod op;
-pub use op::{BinOp, UnOp};
-
-mod ty;
-pub use ty::{Abi, AngleBracketedParameterData, BareFnArg, BareFnTy, FunctionRetTy, MutTy,
- Mutability, ParenthesizedParameterData, Path, PathParameters, PathSegment,
- PolyTraitRef, QSelf, Ty, TypeBinding, Unsafety};
-
-#[cfg(feature = "visit")]
-pub mod visit;
-
-#[cfg(feature = "fold")]
-pub mod fold;
-
-#[cfg(feature = "parsing")]
-pub use parsing::*;
-
-#[cfg(feature = "parsing")]
-mod parsing {
- use super::*;
- use {derive, generics, ident, mac, ty, attr};
- use synom::{space, IResult};
-
- #[cfg(feature = "full")]
- use {expr, item, krate};
-
- pub fn parse_derive_input(input: &str) -> Result<DeriveInput, String> {
- unwrap("derive input", derive::parsing::derive_input, input)
- }
-
- #[cfg(feature = "full")]
- pub fn parse_crate(input: &str) -> Result<Crate, String> {
- unwrap("crate", krate::parsing::krate, input)
- }
-
- #[cfg(feature = "full")]
- pub fn parse_item(input: &str) -> Result<Item, String> {
- unwrap("item", item::parsing::item, input)
- }
-
- #[cfg(feature = "full")]
- pub fn parse_items(input: &str) -> Result<Vec<Item>, String> {
- unwrap("items", item::parsing::items, input)
- }
-
- #[cfg(feature = "full")]
- pub fn parse_expr(input: &str) -> Result<Expr, String> {
- unwrap("expression", expr::parsing::expr, input)
- }
-
- pub fn parse_type(input: &str) -> Result<Ty, String> {
- unwrap("type", ty::parsing::ty, input)
- }
-
- pub fn parse_path(input: &str) -> Result<Path, String> {
- unwrap("path", ty::parsing::path, input)
- }
-
- pub fn parse_where_clause(input: &str) -> Result<WhereClause, String> {
- unwrap("where clause", generics::parsing::where_clause, input)
- }
-
- pub fn parse_token_trees(input: &str) -> Result<Vec<TokenTree>, String> {
- unwrap("token trees", mac::parsing::token_trees, input)
- }
-
- pub fn parse_ident(input: &str) -> Result<Ident, String> {
- unwrap("identifier", ident::parsing::ident, input)
- }
-
- pub fn parse_ty_param_bound(input: &str) -> Result<TyParamBound, String> {
- unwrap("type parameter bound",
- generics::parsing::ty_param_bound,
- input)
- }
-
- pub fn parse_outer_attr(input: &str) -> Result<Attribute, String> {
- unwrap("outer attribute", attr::parsing::outer_attr, input)
- }
-
- #[cfg(feature = "full")]
- pub fn parse_inner_attr(input: &str) -> Result<Attribute, String> {
- unwrap("inner attribute", attr::parsing::inner_attr, input)
- }
-
- // Deprecated. Use `parse_derive_input` instead.
- #[doc(hidden)]
- pub fn parse_macro_input(input: &str) -> Result<MacroInput, String> {
- parse_derive_input(input)
- }
-
- fn unwrap<T>(name: &'static str,
- f: fn(&str) -> IResult<&str, T>,
- input: &str)
- -> Result<T, String> {
- match f(input) {
- IResult::Done(mut rest, t) => {
- rest = space::skip_whitespace(rest);
- if rest.is_empty() {
- Ok(t)
- } else if rest.len() == input.len() {
- // parsed nothing
- Err(format!("failed to parse {}: {:?}", name, rest))
- } else {
- Err(format!("unparsed tokens after {}: {:?}", name, rest))
- }
- }
- IResult::Error => Err(format!("failed to parse {}: {:?}", name, input)),
- }
- }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parse {
- //! This module contains a set of exported nom parsers which can be used to
- //! parse custom grammars when used alongside the `synom` crate.
- //!
- //! Internally, `syn` uses a fork of `nom` called `synom` which resolves a
- //! persistent pitfall of using `nom` to parse Rust by eliminating the
- //! `IResult::Incomplete` variant. The `synom` crate should be used instead
- //! of `nom` when working with the parsers in this module.
-
- pub use synom::IResult;
-
- #[cfg(feature = "full")]
- pub use item::parsing::item;
-
- #[cfg(feature = "full")]
- pub use expr::parsing::{expr, pat, block, stmt};
-
- pub use lit::parsing::{lit, string, byte_string, byte, character, float, int, boolean};
-
- pub use ty::parsing::{ty, path};
-
- pub use mac::parsing::token_tree as tt;
-
- pub use ident::parsing::ident;
-
- pub use generics::parsing::lifetime;
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/lit.rs
+++ /dev/null
@@ -1,484 +0,0 @@
-/// Literal kind.
-///
-/// E.g. `"foo"`, `42`, `12.34` or `bool`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Lit {
- /// A string literal (`"foo"`)
- Str(String, StrStyle),
- /// A byte string (`b"foo"`)
- ByteStr(Vec<u8>, StrStyle),
- /// A byte char (`b'f'`)
- Byte(u8),
- /// A character literal (`'a'`)
- Char(char),
- /// An integer literal (`1`)
- Int(u64, IntTy),
- /// A float literal (`1f64` or `1E10f64` or `1.0E10`)
- Float(String, FloatTy),
- /// A boolean literal
- Bool(bool),
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum StrStyle {
- /// A regular string, like `"foo"`
- Cooked,
- /// A raw string, like `r##"foo"##`
- ///
- /// The uint is the number of `#` symbols used
- Raw(usize),
-}
-
-impl From<String> for Lit {
- fn from(input: String) -> Lit {
- Lit::Str(input, StrStyle::Cooked)
- }
-}
-
-impl<'a> From<&'a str> for Lit {
- fn from(input: &str) -> Lit {
- Lit::Str(input.into(), StrStyle::Cooked)
- }
-}
-
-impl From<Vec<u8>> for Lit {
- fn from(input: Vec<u8>) -> Lit {
- Lit::ByteStr(input, StrStyle::Cooked)
- }
-}
-
-impl<'a> From<&'a [u8]> for Lit {
- fn from(input: &[u8]) -> Lit {
- Lit::ByteStr(input.into(), StrStyle::Cooked)
- }
-}
-
-impl From<char> for Lit {
- fn from(input: char) -> Lit {
- Lit::Char(input)
- }
-}
-
-impl From<bool> for Lit {
- fn from(input: bool) -> Lit {
- Lit::Bool(input)
- }
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum IntTy {
- Isize,
- I8,
- I16,
- I32,
- I64,
- Usize,
- U8,
- U16,
- U32,
- U64,
- Unsuffixed,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum FloatTy {
- F32,
- F64,
- Unsuffixed,
-}
-
-macro_rules! impl_from_for_lit {
- (Int, [$($rust_type:ty => $syn_type:expr),+]) => {
- $(
- impl From<$rust_type> for Lit {
- fn from(input: $rust_type) -> Lit {
- Lit::Int(input as u64, $syn_type)
- }
- }
- )+
- };
- (Float, [$($rust_type:ty => $syn_type:expr),+]) => {
- $(
- impl From<$rust_type> for Lit {
- fn from(input: $rust_type) -> Lit {
- Lit::Float(format!("{}", input), $syn_type)
- }
- }
- )+
- };
-}
-
-impl_from_for_lit! {Int, [
- isize => IntTy::Isize,
- i8 => IntTy::I8,
- i16 => IntTy::I16,
- i32 => IntTy::I32,
- i64 => IntTy::I64,
- usize => IntTy::Usize,
- u8 => IntTy::U8,
- u16 => IntTy::U16,
- u32 => IntTy::U32,
- u64 => IntTy::U64
-]}
-
-impl_from_for_lit! {Float, [
- f32 => FloatTy::F32,
- f64 => FloatTy::F64
-]}
-
-#[cfg(feature = "parsing")]
-#[derive(Debug, Clone)]
-pub struct StrLit {
- pub value: String,
- pub style: StrStyle,
-}
-
-#[cfg(feature = "parsing")]
-#[derive(Debug, Clone)]
-pub struct ByteStrLit {
- pub value: Vec<u8>,
- pub style: StrStyle,
-}
-
-#[cfg(feature = "parsing")]
-#[derive(Debug, Clone)]
-pub struct IntLit {
- pub value: u64,
- pub suffix: IntTy,
-}
-
-#[cfg(feature = "parsing")]
-#[derive(Debug, Clone)]
-pub struct FloatLit {
- pub value: String,
- pub suffix: FloatTy,
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use escape::{cooked_byte, cooked_byte_string, cooked_char, cooked_string, raw_string};
- use synom::space::skip_whitespace;
- use synom::IResult;
- use unicode_xid::UnicodeXID;
-
- named!(pub lit -> Lit, alt!(
- string => { |StrLit { value, style }| Lit::Str(value, style) }
- |
- byte_string => { |ByteStrLit { value, style }| Lit::ByteStr(value, style) }
- |
- byte => { |b| Lit::Byte(b) }
- |
- character => { |ch| Lit::Char(ch) }
- |
- float => { |FloatLit { value, suffix }| Lit::Float(value, suffix) } // must be before int
- |
- int => { |IntLit { value, suffix }| Lit::Int(value, suffix) }
- |
- boolean => { |value| Lit::Bool(value) }
- ));
-
- named!(pub string -> StrLit, alt!(
- quoted_string => { |s| StrLit { value: s, style: StrStyle::Cooked } }
- |
- preceded!(
- punct!("r"),
- raw_string
- ) => { |(s, n)| StrLit { value: s, style: StrStyle::Raw(n) }}
- ));
-
- named!(pub quoted_string -> String, delimited!(
- punct!("\""),
- cooked_string,
- tag!("\"")
- ));
-
- named!(pub byte_string -> ByteStrLit, alt!(
- delimited!(
- punct!("b\""),
- cooked_byte_string,
- tag!("\"")
- ) => { |vec| ByteStrLit { value: vec, style: StrStyle::Cooked } }
- |
- preceded!(
- punct!("br"),
- raw_string
- ) => { |(s, n): (String, _)| ByteStrLit { value: s.into_bytes(), style: StrStyle::Raw(n) } }
- ));
-
- named!(pub byte -> u8, do_parse!(
- punct!("b") >>
- tag!("'") >>
- b: cooked_byte >>
- tag!("'") >>
- (b)
- ));
-
- named!(pub character -> char, do_parse!(
- punct!("'") >>
- ch: cooked_char >>
- tag!("'") >>
- (ch)
- ));
-
- named!(pub float -> FloatLit, do_parse!(
- value: float_string >>
- suffix: alt!(
- tag!("f32") => { |_| FloatTy::F32 }
- |
- tag!("f64") => { |_| FloatTy::F64 }
- |
- epsilon!() => { |_| FloatTy::Unsuffixed }
- ) >>
- (FloatLit { value: value, suffix: suffix })
- ));
-
- named!(pub int -> IntLit, do_parse!(
- value: digits >>
- suffix: alt!(
- tag!("isize") => { |_| IntTy::Isize }
- |
- tag!("i8") => { |_| IntTy::I8 }
- |
- tag!("i16") => { |_| IntTy::I16 }
- |
- tag!("i32") => { |_| IntTy::I32 }
- |
- tag!("i64") => { |_| IntTy::I64 }
- |
- tag!("usize") => { |_| IntTy::Usize }
- |
- tag!("u8") => { |_| IntTy::U8 }
- |
- tag!("u16") => { |_| IntTy::U16 }
- |
- tag!("u32") => { |_| IntTy::U32 }
- |
- tag!("u64") => { |_| IntTy::U64 }
- |
- epsilon!() => { |_| IntTy::Unsuffixed }
- ) >>
- (IntLit { value: value, suffix: suffix })
- ));
-
- named!(pub boolean -> bool, alt!(
- keyword!("true") => { |_| true }
- |
- keyword!("false") => { |_| false }
- ));
-
- fn float_string(mut input: &str) -> IResult<&str, String> {
- input = skip_whitespace(input);
-
- let mut chars = input.chars().peekable();
- match chars.next() {
- Some(ch) if ch >= '0' && ch <= '9' => {}
- _ => return IResult::Error,
- }
-
- let mut len = 1;
- let mut has_dot = false;
- let mut has_exp = false;
- while let Some(&ch) = chars.peek() {
- match ch {
- '0'...'9' | '_' => {
- chars.next();
- len += 1;
- }
- '.' => {
- if has_dot {
- break;
- }
- chars.next();
- if chars.peek()
- .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
- .unwrap_or(false) {
- return IResult::Error;
- }
- len += 1;
- has_dot = true;
- }
- 'e' | 'E' => {
- chars.next();
- len += 1;
- has_exp = true;
- break;
- }
- _ => break,
- }
- }
-
- let rest = &input[len..];
- if !(has_dot || has_exp || rest.starts_with("f32") || rest.starts_with("f64")) {
- return IResult::Error;
- }
-
- if has_exp {
- let mut has_exp_value = false;
- while let Some(&ch) = chars.peek() {
- match ch {
- '+' | '-' => {
- if has_exp_value {
- break;
- }
- chars.next();
- len += 1;
- }
- '0'...'9' => {
- chars.next();
- len += 1;
- has_exp_value = true;
- }
- '_' => {
- chars.next();
- len += 1;
- }
- _ => break,
- }
- }
- if !has_exp_value {
- return IResult::Error;
- }
- }
-
- IResult::Done(&input[len..], input[..len].replace("_", ""))
- }
-
- pub fn digits(mut input: &str) -> IResult<&str, u64> {
- input = skip_whitespace(input);
-
- let base = if input.starts_with("0x") {
- input = &input[2..];
- 16
- } else if input.starts_with("0o") {
- input = &input[2..];
- 8
- } else if input.starts_with("0b") {
- input = &input[2..];
- 2
- } else {
- 10
- };
-
- let mut value = 0u64;
- let mut len = 0;
- let mut empty = true;
- for b in input.bytes() {
- let digit = match b {
- b'0'...b'9' => (b - b'0') as u64,
- b'a'...b'f' => 10 + (b - b'a') as u64,
- b'A'...b'F' => 10 + (b - b'A') as u64,
- b'_' => {
- if empty && base == 10 {
- return IResult::Error;
- }
- len += 1;
- continue;
- }
- _ => break,
- };
- if digit >= base {
- return IResult::Error;
- }
- value = match value.checked_mul(base) {
- Some(value) => value,
- None => return IResult::Error,
- };
- value = match value.checked_add(digit) {
- Some(value) => value,
- None => return IResult::Error,
- };
- len += 1;
- empty = false;
- }
- if empty {
- IResult::Error
- } else {
- IResult::Done(&input[len..], value)
- }
- }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
- use std::{ascii, iter};
- use std::fmt::{self, Display};
- use std::str;
-
- impl ToTokens for Lit {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Lit::Str(ref s, StrStyle::Cooked) => s.to_tokens(tokens),
- Lit::Str(ref s, StrStyle::Raw(n)) => {
- tokens.append(&format!("r{delim}\"{string}\"{delim}",
- delim = iter::repeat("#").take(n).collect::<String>(),
- string = s));
- }
- Lit::ByteStr(ref v, StrStyle::Cooked) => {
- let mut escaped = "b\"".to_string();
- for &ch in v.iter() {
- match ch {
- 0 => escaped.push_str(r"\0"),
- b'\'' => escaped.push('\''),
- _ => escaped.extend(ascii::escape_default(ch).map(|c| c as char)),
- }
- }
- escaped.push('"');
- tokens.append(&escaped);
- }
- Lit::ByteStr(ref vec, StrStyle::Raw(n)) => {
- tokens.append(&format!("br{delim}\"{string}\"{delim}",
- delim = iter::repeat("#").take(n).collect::<String>(),
- string = str::from_utf8(vec).unwrap()));
- }
- Lit::Byte(b) => {
- match b {
- 0 => tokens.append(r"b'\0'"),
- b'\"' => tokens.append("b'\"'"),
- _ => {
- let mut escaped = "b'".to_string();
- escaped.extend(ascii::escape_default(b).map(|c| c as char));
- escaped.push('\'');
- tokens.append(&escaped);
- }
- }
- }
- Lit::Char(ch) => ch.to_tokens(tokens),
- Lit::Int(value, ty) => tokens.append(&format!("{}{}", value, ty)),
- Lit::Float(ref value, ty) => tokens.append(&format!("{}{}", value, ty)),
- Lit::Bool(true) => tokens.append("true"),
- Lit::Bool(false) => tokens.append("false"),
- }
- }
- }
-
- impl Display for IntTy {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- match *self {
- IntTy::Isize => formatter.write_str("isize"),
- IntTy::I8 => formatter.write_str("i8"),
- IntTy::I16 => formatter.write_str("i16"),
- IntTy::I32 => formatter.write_str("i32"),
- IntTy::I64 => formatter.write_str("i64"),
- IntTy::Usize => formatter.write_str("usize"),
- IntTy::U8 => formatter.write_str("u8"),
- IntTy::U16 => formatter.write_str("u16"),
- IntTy::U32 => formatter.write_str("u32"),
- IntTy::U64 => formatter.write_str("u64"),
- IntTy::Unsuffixed => Ok(()),
- }
- }
- }
-
- impl Display for FloatTy {
- fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- match *self {
- FloatTy::F32 => formatter.write_str("f32"),
- FloatTy::F64 => formatter.write_str("f64"),
- FloatTy::Unsuffixed => Ok(()),
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/mac.rs
+++ /dev/null
@@ -1,430 +0,0 @@
-use super::*;
-
-/// Represents a macro invocation. The Path indicates which macro
-/// is being invoked, and the vector of token-trees contains the source
-/// of the macro invocation.
-///
-/// NB: the additional ident for a `macro_rules`-style macro is actually
-/// stored in the enclosing item. Oog.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Mac {
- pub path: Path,
- pub tts: Vec<TokenTree>,
-}
-
-/// When the main rust parser encounters a syntax-extension invocation, it
-/// parses the arguments to the invocation as a token-tree. This is a very
-/// loose structure, such that all sorts of different AST-fragments can
-/// be passed to syntax extensions using a uniform type.
-///
-/// If the syntax extension is an MBE macro, it will attempt to match its
-/// LHS token tree against the provided token tree, and if it finds a
-/// match, will transcribe the RHS token tree, splicing in any captured
-/// `macro_parser::matched_nonterminals` into the `SubstNt`s it finds.
-///
-/// The RHS of an MBE macro is the only place `SubstNt`s are substituted.
-/// Nothing special happens to misnamed or misplaced `SubstNt`s.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum TokenTree {
- /// A single token
- Token(Token),
- /// A delimited sequence of token trees
- Delimited(Delimited),
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Delimited {
- /// The type of delimiter
- pub delim: DelimToken,
- /// The delimited sequence of token trees
- pub tts: Vec<TokenTree>,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Token {
- // Expression-operator symbols.
- Eq,
- Lt,
- Le,
- EqEq,
- Ne,
- Ge,
- Gt,
- AndAnd,
- OrOr,
- Not,
- Tilde,
- BinOp(BinOpToken),
- BinOpEq(BinOpToken),
-
- // Structural symbols
- At,
- Dot,
- DotDot,
- DotDotDot,
- Comma,
- Semi,
- Colon,
- ModSep,
- RArrow,
- LArrow,
- FatArrow,
- Pound,
- Dollar,
- Question,
-
- // Literals
- Literal(Lit),
-
- // Name components
- Ident(Ident),
- Underscore,
- Lifetime(Ident),
-
- DocComment(String),
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum BinOpToken {
- Plus,
- Minus,
- Star,
- Slash,
- Percent,
- Caret,
- And,
- Or,
- Shl,
- Shr,
-}
-
-/// A delimiter token
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum DelimToken {
- /// A round parenthesis: `(` or `)`
- Paren,
- /// A square bracket: `[` or `]`
- Bracket,
- /// A curly brace: `{` or `}`
- Brace,
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use Lifetime;
- use generics::parsing::lifetime;
- use ident::parsing::word;
- use lit::parsing::lit;
- use synom::space::{block_comment, whitespace};
- use ty::parsing::path;
-
- named!(pub mac -> Mac, do_parse!(
- what: path >>
- punct!("!") >>
- body: delimited >>
- (Mac {
- path: what,
- tts: vec![TokenTree::Delimited(body)],
- })
- ));
-
- named!(pub token_trees -> Vec<TokenTree>, many0!(token_tree));
-
- named!(pub delimited -> Delimited, alt!(
- delimited!(
- punct!("("),
- token_trees,
- punct!(")")
- ) => { |tts| Delimited { delim: DelimToken::Paren, tts: tts } }
- |
- delimited!(
- punct!("["),
- token_trees,
- punct!("]")
- ) => { |tts| Delimited { delim: DelimToken::Bracket, tts: tts } }
- |
- delimited!(
- punct!("{"),
- token_trees,
- punct!("}")
- ) => { |tts| Delimited { delim: DelimToken::Brace, tts: tts } }
- ));
-
- named!(pub token_tree -> TokenTree, alt!(
- map!(token, TokenTree::Token)
- |
- map!(delimited, TokenTree::Delimited)
- ));
-
- named!(token -> Token, alt!(
- keyword!("_") => { |_| Token::Underscore }
- |
- punct!("&&") => { |_| Token::AndAnd } // must be before BinOp
- |
- punct!("||") => { |_| Token::OrOr } // must be before BinOp
- |
- punct!("->") => { |_| Token::RArrow } // must be before BinOp
- |
- punct!("<-") => { |_| Token::LArrow } // must be before Lt
- |
- punct!("=>") => { |_| Token::FatArrow } // must be before Eq
- |
- punct!("...") => { |_| Token::DotDotDot } // must be before DotDot
- |
- punct!("..") => { |_| Token::DotDot } // must be before Dot
- |
- punct!(".") => { |_| Token::Dot }
- |
- map!(doc_comment, Token::DocComment) // must be before bin_op
- |
- map!(bin_op_eq, Token::BinOpEq) // must be before bin_op
- |
- map!(bin_op, Token::BinOp)
- |
- map!(lit, Token::Literal)
- |
- map!(word, Token::Ident)
- |
- map!(lifetime, |lt: Lifetime| Token::Lifetime(lt.ident))
- |
- punct!("<=") => { |_| Token::Le }
- |
- punct!("==") => { |_| Token::EqEq }
- |
- punct!("!=") => { |_| Token::Ne }
- |
- punct!(">=") => { |_| Token::Ge }
- |
- punct!("::") => { |_| Token::ModSep }
- |
- punct!("=") => { |_| Token::Eq }
- |
- punct!("<") => { |_| Token::Lt }
- |
- punct!(">") => { |_| Token::Gt }
- |
- punct!("!") => { |_| Token::Not }
- |
- punct!("~") => { |_| Token::Tilde }
- |
- punct!("@") => { |_| Token::At }
- |
- punct!(",") => { |_| Token::Comma }
- |
- punct!(";") => { |_| Token::Semi }
- |
- punct!(":") => { |_| Token::Colon }
- |
- punct!("#") => { |_| Token::Pound }
- |
- punct!("$") => { |_| Token::Dollar }
- |
- punct!("?") => { |_| Token::Question }
- ));
-
- named!(bin_op -> BinOpToken, alt!(
- punct!("+") => { |_| BinOpToken::Plus }
- |
- punct!("-") => { |_| BinOpToken::Minus }
- |
- punct!("*") => { |_| BinOpToken::Star }
- |
- punct!("/") => { |_| BinOpToken::Slash }
- |
- punct!("%") => { |_| BinOpToken::Percent }
- |
- punct!("^") => { |_| BinOpToken::Caret }
- |
- punct!("&") => { |_| BinOpToken::And }
- |
- punct!("|") => { |_| BinOpToken::Or }
- |
- punct!("<<") => { |_| BinOpToken::Shl }
- |
- punct!(">>") => { |_| BinOpToken::Shr }
- ));
-
- named!(bin_op_eq -> BinOpToken, alt!(
- punct!("+=") => { |_| BinOpToken::Plus }
- |
- punct!("-=") => { |_| BinOpToken::Minus }
- |
- punct!("*=") => { |_| BinOpToken::Star }
- |
- punct!("/=") => { |_| BinOpToken::Slash }
- |
- punct!("%=") => { |_| BinOpToken::Percent }
- |
- punct!("^=") => { |_| BinOpToken::Caret }
- |
- punct!("&=") => { |_| BinOpToken::And }
- |
- punct!("|=") => { |_| BinOpToken::Or }
- |
- punct!("<<=") => { |_| BinOpToken::Shl }
- |
- punct!(">>=") => { |_| BinOpToken::Shr }
- ));
-
- named!(doc_comment -> String, alt!(
- do_parse!(
- punct!("//!") >>
- content: take_until!("\n") >>
- (format!("//!{}", content))
- )
- |
- do_parse!(
- option!(whitespace) >>
- peek!(tag!("/*!")) >>
- com: block_comment >>
- (com.to_owned())
- )
- |
- do_parse!(
- punct!("///") >>
- not!(tag!("/")) >>
- content: take_until!("\n") >>
- (format!("///{}", content))
- )
- |
- do_parse!(
- option!(whitespace) >>
- peek!(tuple!(tag!("/**"), not!(tag!("*")))) >>
- com: block_comment >>
- (com.to_owned())
- )
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Mac {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.path.to_tokens(tokens);
- tokens.append("!");
- for tt in &self.tts {
- tt.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for TokenTree {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- TokenTree::Token(ref token) => token.to_tokens(tokens),
- TokenTree::Delimited(ref delimited) => delimited.to_tokens(tokens),
- }
- }
- }
-
- impl DelimToken {
- fn open(&self) -> &'static str {
- match *self {
- DelimToken::Paren => "(",
- DelimToken::Bracket => "[",
- DelimToken::Brace => "{",
- }
- }
-
- fn close(&self) -> &'static str {
- match *self {
- DelimToken::Paren => ")",
- DelimToken::Bracket => "]",
- DelimToken::Brace => "}",
- }
- }
- }
-
- impl ToTokens for Delimited {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(self.delim.open());
- for tt in &self.tts {
- tt.to_tokens(tokens);
- }
- tokens.append(self.delim.close());
- }
- }
-
- impl ToTokens for Token {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Token::Eq => tokens.append("="),
- Token::Lt => tokens.append("<"),
- Token::Le => tokens.append("<="),
- Token::EqEq => tokens.append("=="),
- Token::Ne => tokens.append("!="),
- Token::Ge => tokens.append(">="),
- Token::Gt => tokens.append(">"),
- Token::AndAnd => tokens.append("&&"),
- Token::OrOr => tokens.append("||"),
- Token::Not => tokens.append("!"),
- Token::Tilde => tokens.append("~"),
- Token::BinOp(binop) => tokens.append(binop.op()),
- Token::BinOpEq(binop) => tokens.append(binop.assign_op()),
- Token::At => tokens.append("@"),
- Token::Dot => tokens.append("."),
- Token::DotDot => tokens.append(".."),
- Token::DotDotDot => tokens.append("..."),
- Token::Comma => tokens.append(","),
- Token::Semi => tokens.append(";"),
- Token::Colon => tokens.append(":"),
- Token::ModSep => tokens.append("::"),
- Token::RArrow => tokens.append("->"),
- Token::LArrow => tokens.append("<-"),
- Token::FatArrow => tokens.append("=>"),
- Token::Pound => tokens.append("#"),
- Token::Dollar => tokens.append("$"),
- Token::Question => tokens.append("?"),
- Token::Literal(ref lit) => lit.to_tokens(tokens),
- Token::Ident(ref ident) |
- Token::Lifetime(ref ident) => ident.to_tokens(tokens),
- Token::Underscore => tokens.append("_"),
- Token::DocComment(ref com) => {
- tokens.append(&format!("{}\n", com));
- }
- }
- }
- }
-
- impl BinOpToken {
- fn op(&self) -> &'static str {
- match *self {
- BinOpToken::Plus => "+",
- BinOpToken::Minus => "-",
- BinOpToken::Star => "*",
- BinOpToken::Slash => "/",
- BinOpToken::Percent => "%",
- BinOpToken::Caret => "^",
- BinOpToken::And => "&",
- BinOpToken::Or => "|",
- BinOpToken::Shl => "<<",
- BinOpToken::Shr => ">>",
- }
- }
-
- fn assign_op(&self) -> &'static str {
- match *self {
- BinOpToken::Plus => "+=",
- BinOpToken::Minus => "-=",
- BinOpToken::Star => "*=",
- BinOpToken::Slash => "/=",
- BinOpToken::Percent => "%=",
- BinOpToken::Caret => "^=",
- BinOpToken::And => "&=",
- BinOpToken::Or => "|=",
- BinOpToken::Shl => "<<=",
- BinOpToken::Shr => ">>=",
- }
- }
- }
-
- impl ToTokens for BinOpToken {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(self.op());
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/op.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum BinOp {
- /// The `+` operator (addition)
- Add,
- /// The `-` operator (subtraction)
- Sub,
- /// The `*` operator (multiplication)
- Mul,
- /// The `/` operator (division)
- Div,
- /// The `%` operator (modulus)
- Rem,
- /// The `&&` operator (logical and)
- And,
- /// The `||` operator (logical or)
- Or,
- /// The `^` operator (bitwise xor)
- BitXor,
- /// The `&` operator (bitwise and)
- BitAnd,
- /// The `|` operator (bitwise or)
- BitOr,
- /// The `<<` operator (shift left)
- Shl,
- /// The `>>` operator (shift right)
- Shr,
- /// The `==` operator (equality)
- Eq,
- /// The `<` operator (less than)
- Lt,
- /// The `<=` operator (less than or equal to)
- Le,
- /// The `!=` operator (not equal to)
- Ne,
- /// The `>=` operator (greater than or equal to)
- Ge,
- /// The `>` operator (greater than)
- Gt,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum UnOp {
- /// The `*` operator for dereferencing
- Deref,
- /// The `!` operator for logical inversion
- Not,
- /// The `-` operator for negation
- Neg,
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
-
- named!(pub binop -> BinOp, alt!(
- punct!("&&") => { |_| BinOp::And }
- |
- punct!("||") => { |_| BinOp::Or }
- |
- punct!("<<") => { |_| BinOp::Shl }
- |
- punct!(">>") => { |_| BinOp::Shr }
- |
- punct!("==") => { |_| BinOp::Eq }
- |
- punct!("<=") => { |_| BinOp::Le }
- |
- punct!("!=") => { |_| BinOp::Ne }
- |
- punct!(">=") => { |_| BinOp::Ge }
- |
- punct!("+") => { |_| BinOp::Add }
- |
- punct!("-") => { |_| BinOp::Sub }
- |
- punct!("*") => { |_| BinOp::Mul }
- |
- punct!("/") => { |_| BinOp::Div }
- |
- punct!("%") => { |_| BinOp::Rem }
- |
- punct!("^") => { |_| BinOp::BitXor }
- |
- punct!("&") => { |_| BinOp::BitAnd }
- |
- punct!("|") => { |_| BinOp::BitOr }
- |
- punct!("<") => { |_| BinOp::Lt }
- |
- punct!(">") => { |_| BinOp::Gt }
- ));
-
- #[cfg(feature = "full")]
- named!(pub assign_op -> BinOp, alt!(
- punct!("+=") => { |_| BinOp::Add }
- |
- punct!("-=") => { |_| BinOp::Sub }
- |
- punct!("*=") => { |_| BinOp::Mul }
- |
- punct!("/=") => { |_| BinOp::Div }
- |
- punct!("%=") => { |_| BinOp::Rem }
- |
- punct!("^=") => { |_| BinOp::BitXor }
- |
- punct!("&=") => { |_| BinOp::BitAnd }
- |
- punct!("|=") => { |_| BinOp::BitOr }
- |
- punct!("<<=") => { |_| BinOp::Shl }
- |
- punct!(">>=") => { |_| BinOp::Shr }
- ));
-
- named!(pub unop -> UnOp, alt!(
- punct!("*") => { |_| UnOp::Deref }
- |
- punct!("!") => { |_| UnOp::Not }
- |
- punct!("-") => { |_| UnOp::Neg }
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
-
- impl BinOp {
- pub fn op(&self) -> &'static str {
- match *self {
- BinOp::Add => "+",
- BinOp::Sub => "-",
- BinOp::Mul => "*",
- BinOp::Div => "/",
- BinOp::Rem => "%",
- BinOp::And => "&&",
- BinOp::Or => "||",
- BinOp::BitXor => "^",
- BinOp::BitAnd => "&",
- BinOp::BitOr => "|",
- BinOp::Shl => "<<",
- BinOp::Shr => ">>",
- BinOp::Eq => "==",
- BinOp::Lt => "<",
- BinOp::Le => "<=",
- BinOp::Ne => "!=",
- BinOp::Ge => ">=",
- BinOp::Gt => ">",
- }
- }
-
- pub fn assign_op(&self) -> Option<&'static str> {
- match *self {
- BinOp::Add => Some("+="),
- BinOp::Sub => Some("-="),
- BinOp::Mul => Some("*="),
- BinOp::Div => Some("/="),
- BinOp::Rem => Some("%="),
- BinOp::BitXor => Some("^="),
- BinOp::BitAnd => Some("&="),
- BinOp::BitOr => Some("|="),
- BinOp::Shl => Some("<<="),
- BinOp::Shr => Some(">>="),
- _ => None,
- }
- }
- }
-
- impl ToTokens for BinOp {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(self.op());
- }
- }
-
- impl UnOp {
- pub fn op(&self) -> &'static str {
- match *self {
- UnOp::Deref => "*",
- UnOp::Not => "!",
- UnOp::Neg => "-",
- }
- }
- }
-
- impl ToTokens for UnOp {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(self.op());
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/ty.rs
+++ /dev/null
@@ -1,844 +0,0 @@
-use super::*;
-
-/// The different kinds of types recognized by the compiler
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Ty {
- /// A variable-length array (`[T]`)
- Slice(Box<Ty>),
- /// A fixed length array (`[T; n]`)
- Array(Box<Ty>, ConstExpr),
- /// A raw pointer (`*const T` or `*mut T`)
- Ptr(Box<MutTy>),
- /// A reference (`&'a T` or `&'a mut T`)
- Rptr(Option<Lifetime>, Box<MutTy>),
- /// A bare function (e.g. `fn(usize) -> bool`)
- BareFn(Box<BareFnTy>),
- /// The never type (`!`)
- Never,
- /// A tuple (`(A, B, C, D, ...)`)
- Tup(Vec<Ty>),
- /// A path (`module::module::...::Type`), optionally
- /// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`.
- ///
- /// Type parameters are stored in the Path itself
- Path(Option<QSelf>, Path),
- /// A trait object type `Bound1 + Bound2 + Bound3`
- /// where `Bound` is a trait or a lifetime.
- TraitObject(Vec<TyParamBound>),
- /// An `impl Bound1 + Bound2 + Bound3` type
- /// where `Bound` is a trait or a lifetime.
- ImplTrait(Vec<TyParamBound>),
- /// No-op; kept solely so that we can pretty-print faithfully
- Paren(Box<Ty>),
- /// TyKind::Infer means the type should be inferred instead of it having been
- /// specified. This can appear anywhere in a type.
- Infer,
- /// A macro in the type position.
- Mac(Mac),
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct MutTy {
- pub ty: Ty,
- pub mutability: Mutability,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Mutability {
- Mutable,
- Immutable,
-}
-
-/// A "Path" is essentially Rust's notion of a name.
-///
-/// It's represented as a sequence of identifiers,
-/// along with a bunch of supporting information.
-///
-/// E.g. `std::cmp::PartialEq`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Path {
- /// A `::foo` path, is relative to the crate root rather than current
- /// module (like paths in an import).
- pub global: bool,
- /// The segments in the path: the things separated by `::`.
- pub segments: Vec<PathSegment>,
-}
-
-impl<T> From<T> for Path
- where T: Into<PathSegment>
-{
- fn from(segment: T) -> Self {
- Path {
- global: false,
- segments: vec![segment.into()],
- }
- }
-}
-
-/// A segment of a path: an identifier, an optional lifetime, and a set of types.
-///
-/// E.g. `std`, `String` or `Box<T>`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct PathSegment {
- /// The identifier portion of this path segment.
- pub ident: Ident,
- /// Type/lifetime parameters attached to this path. They come in
- /// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`. Note that
- /// this is more than just simple syntactic sugar; the use of
- /// parens affects the region binding rules, so we preserve the
- /// distinction.
- pub parameters: PathParameters,
-}
-
-impl<T> From<T> for PathSegment
- where T: Into<Ident>
-{
- fn from(ident: T) -> Self {
- PathSegment {
- ident: ident.into(),
- parameters: PathParameters::none(),
- }
- }
-}
-
-/// Parameters of a path segment.
-///
-/// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum PathParameters {
- /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`
- AngleBracketed(AngleBracketedParameterData),
- /// The `(A, B)` and `C` in `Foo(A, B) -> C`
- Parenthesized(ParenthesizedParameterData),
-}
-
-impl PathParameters {
- pub fn none() -> Self {
- PathParameters::AngleBracketed(AngleBracketedParameterData::default())
- }
-
- pub fn is_empty(&self) -> bool {
- match *self {
- PathParameters::AngleBracketed(ref bracketed) => {
- bracketed.lifetimes.is_empty() && bracketed.types.is_empty() &&
- bracketed.bindings.is_empty()
- }
- PathParameters::Parenthesized(_) => false,
- }
- }
-}
-
-/// A path like `Foo<'a, T>`
-#[derive(Debug, Clone, Eq, PartialEq, Default, Hash)]
-pub struct AngleBracketedParameterData {
- /// The lifetime parameters for this path segment.
- pub lifetimes: Vec<Lifetime>,
- /// The type parameters for this path segment, if present.
- pub types: Vec<Ty>,
- /// Bindings (equality constraints) on associated types, if present.
- ///
- /// E.g., `Foo<A=Bar>`.
- pub bindings: Vec<TypeBinding>,
-}
-
-/// Bind a type to an associated type: `A=Foo`.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct TypeBinding {
- pub ident: Ident,
- pub ty: Ty,
-}
-
-/// A path like `Foo(A,B) -> C`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ParenthesizedParameterData {
- /// `(A, B)`
- pub inputs: Vec<Ty>,
- /// `C`
- pub output: Option<Ty>,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct PolyTraitRef {
- /// The `'a` in `<'a> Foo<&'a T>`
- pub bound_lifetimes: Vec<LifetimeDef>,
- /// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
- pub trait_ref: Path,
-}
-
-/// The explicit Self type in a "qualified path". The actual
-/// path, including the trait and the associated item, is stored
-/// separately. `position` represents the index of the associated
-/// item qualified with this Self type.
-///
-/// ```rust,ignore
-/// <Vec<T> as a::b::Trait>::AssociatedItem
-/// ^~~~~ ~~~~~~~~~~~~~~^
-/// ty position = 3
-///
-/// <Vec<T>>::AssociatedItem
-/// ^~~~~ ^
-/// ty position = 0
-/// ```
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct QSelf {
- pub ty: Box<Ty>,
- pub position: usize,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct BareFnTy {
- pub unsafety: Unsafety,
- pub abi: Option<Abi>,
- pub lifetimes: Vec<LifetimeDef>,
- pub inputs: Vec<BareFnArg>,
- pub output: FunctionRetTy,
- pub variadic: bool,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Unsafety {
- Unsafe,
- Normal,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum Abi {
- Named(String),
- Rust,
-}
-
-/// An argument in a function type.
-///
-/// E.g. `bar: usize` as in `fn foo(bar: usize)`
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct BareFnArg {
- pub name: Option<Ident>,
- pub ty: Ty,
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum FunctionRetTy {
- /// Return type is not specified.
- ///
- /// Functions default to `()` and
- /// closures default to inference. Span points to where return
- /// type would be inserted.
- Default,
- /// Everything else
- Ty(Ty),
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
- use super::*;
- use {TyParamBound, TraitBoundModifier};
- #[cfg(feature = "full")]
- use ConstExpr;
- #[cfg(feature = "full")]
- use constant::parsing::const_expr;
- #[cfg(feature = "full")]
- use expr::parsing::expr;
- use generics::parsing::{lifetime, lifetime_def, ty_param_bound, bound_lifetimes};
- use ident::parsing::ident;
- use lit::parsing::quoted_string;
- use mac::parsing::mac;
- use std::str;
-
- named!(pub ty -> Ty, alt!(
- ty_paren // must be before ty_tup
- |
- ty_mac // must be before ty_path
- |
- ty_path // must be before ty_poly_trait_ref
- |
- ty_vec
- |
- ty_array
- |
- ty_ptr
- |
- ty_rptr
- |
- ty_bare_fn
- |
- ty_never
- |
- ty_tup
- |
- ty_poly_trait_ref
- |
- ty_impl_trait
- ));
-
- named!(ty_mac -> Ty, map!(mac, Ty::Mac));
-
- named!(ty_vec -> Ty, do_parse!(
- punct!("[") >>
- elem: ty >>
- punct!("]") >>
- (Ty::Slice(Box::new(elem)))
- ));
-
- named!(ty_array -> Ty, do_parse!(
- punct!("[") >>
- elem: ty >>
- punct!(";") >>
- len: array_len >>
- punct!("]") >>
- (Ty::Array(Box::new(elem), len))
- ));
-
- #[cfg(not(feature = "full"))]
- use constant::parsing::const_expr as array_len;
-
- #[cfg(feature = "full")]
- named!(array_len -> ConstExpr, alt!(
- terminated!(const_expr, after_array_len)
- |
- terminated!(expr, after_array_len) => { ConstExpr::Other }
- ));
-
- #[cfg(feature = "full")]
- named!(after_array_len -> &str, peek!(punct!("]")));
-
- named!(ty_ptr -> Ty, do_parse!(
- punct!("*") >>
- mutability: alt!(
- keyword!("const") => { |_| Mutability::Immutable }
- |
- keyword!("mut") => { |_| Mutability::Mutable }
- ) >>
- target: ty >>
- (Ty::Ptr(Box::new(MutTy {
- ty: target,
- mutability: mutability,
- })))
- ));
-
- named!(ty_rptr -> Ty, do_parse!(
- punct!("&") >>
- life: option!(lifetime) >>
- mutability: mutability >>
- target: ty >>
- (Ty::Rptr(life, Box::new(MutTy {
- ty: target,
- mutability: mutability,
- })))
- ));
-
- named!(ty_bare_fn -> Ty, do_parse!(
- lifetimes: opt_vec!(do_parse!(
- keyword!("for") >>
- punct!("<") >>
- lifetimes: terminated_list!(punct!(","), lifetime_def) >>
- punct!(">") >>
- (lifetimes)
- )) >>
- unsafety: unsafety >>
- abi: option!(abi) >>
- keyword!("fn") >>
- punct!("(") >>
- inputs: separated_list!(punct!(","), fn_arg) >>
- trailing_comma: option!(punct!(",")) >>
- variadic: option!(cond_reduce!(trailing_comma.is_some(), punct!("..."))) >>
- punct!(")") >>
- output: option!(preceded!(
- punct!("->"),
- ty
- )) >>
- (Ty::BareFn(Box::new(BareFnTy {
- unsafety: unsafety,
- abi: abi,
- lifetimes: lifetimes,
- inputs: inputs,
- output: match output {
- Some(ty) => FunctionRetTy::Ty(ty),
- None => FunctionRetTy::Default,
- },
- variadic: variadic.is_some(),
- })))
- ));
-
- named!(ty_never -> Ty, map!(punct!("!"), |_| Ty::Never));
-
- named!(ty_tup -> Ty, do_parse!(
- punct!("(") >>
- elems: terminated_list!(punct!(","), ty) >>
- punct!(")") >>
- (Ty::Tup(elems))
- ));
-
- named!(ty_path -> Ty, do_parse!(
- qpath: qpath >>
- parenthesized: cond!(
- qpath.1.segments.last().unwrap().parameters == PathParameters::none(),
- option!(parenthesized_parameter_data)
- ) >>
- bounds: many0!(preceded!(punct!("+"), ty_param_bound)) >>
- ({
- let (qself, mut path) = qpath;
- if let Some(Some(parenthesized)) = parenthesized {
- path.segments.last_mut().unwrap().parameters = parenthesized;
- }
- if bounds.is_empty() {
- Ty::Path(qself, path)
- } else {
- let path = TyParamBound::Trait(
- PolyTraitRef {
- bound_lifetimes: Vec::new(),
- trait_ref: path,
- },
- TraitBoundModifier::None,
- );
- let bounds = Some(path).into_iter().chain(bounds).collect();
- Ty::TraitObject(bounds)
- }
- })
- ));
-
- named!(parenthesized_parameter_data -> PathParameters, do_parse!(
- punct!("(") >>
- inputs: terminated_list!(punct!(","), ty) >>
- punct!(")") >>
- output: option!(preceded!(
- punct!("->"),
- ty
- )) >>
- (PathParameters::Parenthesized(
- ParenthesizedParameterData {
- inputs: inputs,
- output: output,
- },
- ))
- ));
-
- named!(pub qpath -> (Option<QSelf>, Path), alt!(
- map!(path, |p| (None, p))
- |
- do_parse!(
- punct!("<") >>
- this: map!(ty, Box::new) >>
- path: option!(preceded!(
- keyword!("as"),
- path
- )) >>
- punct!(">") >>
- punct!("::") >>
- rest: separated_nonempty_list!(punct!("::"), path_segment) >>
- ({
- match path {
- Some(mut path) => {
- let pos = path.segments.len();
- path.segments.extend(rest);
- (Some(QSelf { ty: this, position: pos }), path)
- }
- None => {
- (Some(QSelf { ty: this, position: 0 }), Path {
- global: false,
- segments: rest,
- })
- }
- }
- })
- )
- |
- map!(keyword!("self"), |_| (None, "self".into()))
- ));
-
- named!(ty_poly_trait_ref -> Ty, map!(
- separated_nonempty_list!(punct!("+"), ty_param_bound),
- Ty::TraitObject
- ));
-
- named!(ty_impl_trait -> Ty, do_parse!(
- keyword!("impl") >>
- elem: separated_nonempty_list!(punct!("+"), ty_param_bound) >>
- (Ty::ImplTrait(elem))
- ));
-
- named!(ty_paren -> Ty, do_parse!(
- punct!("(") >>
- elem: ty >>
- punct!(")") >>
- (Ty::Paren(Box::new(elem)))
- ));
-
- named!(pub mutability -> Mutability, alt!(
- keyword!("mut") => { |_| Mutability::Mutable }
- |
- epsilon!() => { |_| Mutability::Immutable }
- ));
-
- named!(pub path -> Path, do_parse!(
- global: option!(punct!("::")) >>
- segments: separated_nonempty_list!(punct!("::"), path_segment) >>
- (Path {
- global: global.is_some(),
- segments: segments,
- })
- ));
-
- named!(path_segment -> PathSegment, alt!(
- do_parse!(
- id: option!(ident) >>
- punct!("<") >>
- lifetimes: separated_list!(punct!(","), lifetime) >>
- types: opt_vec!(preceded!(
- cond!(!lifetimes.is_empty(), punct!(",")),
- separated_nonempty_list!(
- punct!(","),
- terminated!(ty, not!(punct!("=")))
- )
- )) >>
- bindings: opt_vec!(preceded!(
- cond!(!lifetimes.is_empty() || !types.is_empty(), punct!(",")),
- separated_nonempty_list!(punct!(","), type_binding)
- )) >>
- cond!(!lifetimes.is_empty() || !types.is_empty() || !bindings.is_empty(), option!(punct!(","))) >>
- punct!(">") >>
- (PathSegment {
- ident: id.unwrap_or_else(|| "".into()),
- parameters: PathParameters::AngleBracketed(
- AngleBracketedParameterData {
- lifetimes: lifetimes,
- types: types,
- bindings: bindings,
- }
- ),
- })
- )
- |
- map!(ident, Into::into)
- |
- map!(alt!(
- keyword!("super")
- |
- keyword!("self")
- |
- keyword!("Self")
- ), Into::into)
- ));
-
- named!(type_binding -> TypeBinding, do_parse!(
- id: ident >>
- punct!("=") >>
- ty: ty >>
- (TypeBinding {
- ident: id,
- ty: ty,
- })
- ));
-
- named!(pub poly_trait_ref -> PolyTraitRef, do_parse!(
- bound_lifetimes: bound_lifetimes >>
- trait_ref: path >>
- parenthesized: option!(cond_reduce!(
- trait_ref.segments.last().unwrap().parameters == PathParameters::none(),
- parenthesized_parameter_data
- )) >>
- ({
- let mut trait_ref = trait_ref;
- if let Some(parenthesized) = parenthesized {
- trait_ref.segments.last_mut().unwrap().parameters = parenthesized;
- }
- PolyTraitRef {
- bound_lifetimes: bound_lifetimes,
- trait_ref: trait_ref,
- }
- })
- ));
-
- named!(pub fn_arg -> BareFnArg, do_parse!(
- name: option!(do_parse!(
- name: ident >>
- punct!(":") >>
- not!(tag!(":")) >> // not ::
- (name)
- )) >>
- ty: ty >>
- (BareFnArg {
- name: name,
- ty: ty,
- })
- ));
-
- named!(pub unsafety -> Unsafety, alt!(
- keyword!("unsafe") => { |_| Unsafety::Unsafe }
- |
- epsilon!() => { |_| Unsafety::Normal }
- ));
-
- named!(pub abi -> Abi, do_parse!(
- keyword!("extern") >>
- name: option!(quoted_string) >>
- (match name {
- Some(name) => Abi::Named(name),
- None => Abi::Rust,
- })
- ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use quote::{Tokens, ToTokens};
-
- impl ToTokens for Ty {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Ty::Slice(ref inner) => {
- tokens.append("[");
- inner.to_tokens(tokens);
- tokens.append("]");
- }
- Ty::Array(ref inner, ref len) => {
- tokens.append("[");
- inner.to_tokens(tokens);
- tokens.append(";");
- len.to_tokens(tokens);
- tokens.append("]");
- }
- Ty::Ptr(ref target) => {
- tokens.append("*");
- match target.mutability {
- Mutability::Mutable => tokens.append("mut"),
- Mutability::Immutable => tokens.append("const"),
- }
- target.ty.to_tokens(tokens);
- }
- Ty::Rptr(ref lifetime, ref target) => {
- tokens.append("&");
- lifetime.to_tokens(tokens);
- target.mutability.to_tokens(tokens);
- target.ty.to_tokens(tokens);
- }
- Ty::BareFn(ref func) => {
- func.to_tokens(tokens);
- }
- Ty::Never => {
- tokens.append("!");
- }
- Ty::Tup(ref elems) => {
- tokens.append("(");
- tokens.append_separated(elems, ",");
- if elems.len() == 1 {
- tokens.append(",");
- }
- tokens.append(")");
- }
- Ty::Path(None, ref path) => {
- path.to_tokens(tokens);
- }
- Ty::Path(Some(ref qself), ref path) => {
- tokens.append("<");
- qself.ty.to_tokens(tokens);
- if qself.position > 0 {
- tokens.append("as");
- for (i, segment) in path.segments
- .iter()
- .take(qself.position)
- .enumerate() {
- if i > 0 || path.global {
- tokens.append("::");
- }
- segment.to_tokens(tokens);
- }
- }
- tokens.append(">");
- for segment in path.segments.iter().skip(qself.position) {
- tokens.append("::");
- segment.to_tokens(tokens);
- }
- }
- Ty::TraitObject(ref bounds) => {
- tokens.append_separated(bounds, "+");
- }
- Ty::ImplTrait(ref bounds) => {
- tokens.append("impl");
- tokens.append_separated(bounds, "+");
- }
- Ty::Paren(ref inner) => {
- tokens.append("(");
- inner.to_tokens(tokens);
- tokens.append(")");
- }
- Ty::Infer => {
- tokens.append("_");
- }
- Ty::Mac(ref mac) => mac.to_tokens(tokens),
- }
- }
- }
-
- impl ToTokens for Mutability {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if let Mutability::Mutable = *self {
- tokens.append("mut");
- }
- }
- }
-
- impl ToTokens for Path {
- fn to_tokens(&self, tokens: &mut Tokens) {
- for (i, segment) in self.segments.iter().enumerate() {
- if i > 0 || self.global {
- tokens.append("::");
- }
- segment.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for PathSegment {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.ident.to_tokens(tokens);
- if self.ident.as_ref().is_empty() && self.parameters.is_empty() {
- tokens.append("<");
- tokens.append(">");
- } else {
- self.parameters.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for PathParameters {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- PathParameters::AngleBracketed(ref parameters) => {
- parameters.to_tokens(tokens);
- }
- PathParameters::Parenthesized(ref parameters) => {
- parameters.to_tokens(tokens);
- }
- }
- }
- }
-
- impl ToTokens for AngleBracketedParameterData {
- fn to_tokens(&self, tokens: &mut Tokens) {
- let has_lifetimes = !self.lifetimes.is_empty();
- let has_types = !self.types.is_empty();
- let has_bindings = !self.bindings.is_empty();
- if !has_lifetimes && !has_types && !has_bindings {
- return;
- }
-
- tokens.append("<");
-
- let mut first = true;
- for lifetime in &self.lifetimes {
- if !first {
- tokens.append(",");
- }
- lifetime.to_tokens(tokens);
- first = false;
- }
- for ty in &self.types {
- if !first {
- tokens.append(",");
- }
- ty.to_tokens(tokens);
- first = false;
- }
- for binding in &self.bindings {
- if !first {
- tokens.append(",");
- }
- binding.to_tokens(tokens);
- first = false;
- }
-
- tokens.append(">");
- }
- }
-
- impl ToTokens for TypeBinding {
- fn to_tokens(&self, tokens: &mut Tokens) {
- self.ident.to_tokens(tokens);
- tokens.append("=");
- self.ty.to_tokens(tokens);
- }
- }
-
- impl ToTokens for ParenthesizedParameterData {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append("(");
- tokens.append_separated(&self.inputs, ",");
- tokens.append(")");
- if let Some(ref output) = self.output {
- tokens.append("->");
- output.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for PolyTraitRef {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if !self.bound_lifetimes.is_empty() {
- tokens.append("for");
- tokens.append("<");
- tokens.append_separated(&self.bound_lifetimes, ",");
- tokens.append(">");
- }
- self.trait_ref.to_tokens(tokens);
- }
- }
-
- impl ToTokens for BareFnTy {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if !self.lifetimes.is_empty() {
- tokens.append("for");
- tokens.append("<");
- tokens.append_separated(&self.lifetimes, ",");
- tokens.append(">");
- }
- self.unsafety.to_tokens(tokens);
- self.abi.to_tokens(tokens);
- tokens.append("fn");
- tokens.append("(");
- tokens.append_separated(&self.inputs, ",");
- if self.variadic {
- if !self.inputs.is_empty() {
- tokens.append(",");
- }
- tokens.append("...");
- }
- tokens.append(")");
- if let FunctionRetTy::Ty(ref ty) = self.output {
- tokens.append("->");
- ty.to_tokens(tokens);
- }
- }
- }
-
- impl ToTokens for BareFnArg {
- fn to_tokens(&self, tokens: &mut Tokens) {
- if let Some(ref name) = self.name {
- name.to_tokens(tokens);
- tokens.append(":");
- }
- self.ty.to_tokens(tokens);
- }
- }
-
- impl ToTokens for Unsafety {
- fn to_tokens(&self, tokens: &mut Tokens) {
- match *self {
- Unsafety::Unsafe => tokens.append("unsafe"),
- Unsafety::Normal => {
- // nothing
- }
- }
- }
- }
-
- impl ToTokens for Abi {
- fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append("extern");
- match *self {
- Abi::Named(ref named) => named.to_tokens(tokens),
- Abi::Rust => {}
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.11.11/src/visit.rs
+++ /dev/null
@@ -1,778 +0,0 @@
-// Adapted from libsyntax.
-
-//! AST walker. Each overridden visit method has full control over what
-//! happens with its node, it can do its own traversal of the node's children,
-//! call `visit::walk_*` to apply the default traversal algorithm, or prevent
-//! deeper traversal by doing nothing.
-//!
-//! Note: it is an important invariant that the default visitor walks the body
-//! of a function in "execution order" (more concretely, reverse post-order
-//! with respect to the CFG implied by the AST), meaning that if AST node A may
-//! execute before AST node B, then A is visited first. The borrow checker in
-//! particular relies on this property.
-//!
-//! Note: walking an AST before macro expansion is probably a bad idea. For
-//! instance, a walker looking for item names in a module will miss all of
-//! those that are created by the expansion of a macro.
-
-use super::*;
-
-/// Each method of the Visitor trait is a hook to be potentially
-/// overridden. Each method's default implementation recursively visits
-/// the substructure of the input via the corresponding `walk` method;
-/// e.g. the `visit_mod` method by default calls `visit::walk_mod`.
-///
-/// If you want to ensure that your code handles every variant
-/// explicitly, you need to override each method. (And you also need
-/// to monitor future changes to `Visitor` in case a new method with a
-/// new default implementation gets introduced.)
-pub trait Visitor: Sized {
- fn visit_ident(&mut self, _ident: &Ident) {}
- fn visit_derive_input(&mut self, derive_input: &DeriveInput) {
- walk_derive_input(self, derive_input)
- }
- fn visit_ty(&mut self, ty: &Ty) {
- walk_ty(self, ty)
- }
- fn visit_generics(&mut self, generics: &Generics) {
- walk_generics(self, generics)
- }
- fn visit_ty_param_bound(&mut self, bound: &TyParamBound) {
- walk_ty_param_bound(self, bound)
- }
- fn visit_poly_trait_ref(&mut self, trait_ref: &PolyTraitRef, modifier: &TraitBoundModifier) {
- walk_poly_trait_ref(self, trait_ref, modifier)
- }
- fn visit_variant_data(&mut self, data: &VariantData, _ident: &Ident, _generics: &Generics) {
- walk_variant_data(self, data)
- }
- fn visit_field(&mut self, field: &Field) {
- walk_field(self, field)
- }
- fn visit_variant(&mut self, variant: &Variant, generics: &Generics) {
- walk_variant(self, variant, generics)
- }
- fn visit_lifetime(&mut self, _lifetime: &Lifetime) {}
- fn visit_lifetime_def(&mut self, lifetime: &LifetimeDef) {
- walk_lifetime_def(self, lifetime)
- }
- fn visit_path(&mut self, path: &Path) {
- walk_path(self, path)
- }
- fn visit_path_segment(&mut self, path_segment: &PathSegment) {
- walk_path_segment(self, path_segment)
- }
- fn visit_path_parameters(&mut self, path_parameters: &PathParameters) {
- walk_path_parameters(self, path_parameters)
- }
- fn visit_assoc_type_binding(&mut self, type_binding: &TypeBinding) {
- walk_assoc_type_binding(self, type_binding)
- }
- fn visit_attribute(&mut self, _attr: &Attribute) {}
- fn visit_fn_ret_ty(&mut self, ret_ty: &FunctionRetTy) {
- walk_fn_ret_ty(self, ret_ty)
- }
- fn visit_const_expr(&mut self, expr: &ConstExpr) {
- walk_const_expr(self, expr)
- }
- fn visit_lit(&mut self, _lit: &Lit) {}
-
- fn visit_mac(&mut self, mac: &Mac) {
- walk_mac(self, mac);
- }
-
- #[cfg(feature = "full")]
- fn visit_crate(&mut self, _crate: &Crate) {
- walk_crate(self, _crate);
- }
- #[cfg(feature = "full")]
- fn visit_item(&mut self, item: &Item) {
- walk_item(self, item);
- }
- #[cfg(feature = "full")]
- fn visit_expr(&mut self, expr: &Expr) {
- walk_expr(self, expr);
- }
- #[cfg(feature = "full")]
- fn visit_foreign_item(&mut self, foreign_item: &ForeignItem) {
- walk_foreign_item(self, foreign_item);
- }
- #[cfg(feature = "full")]
- fn visit_pat(&mut self, pat: &Pat) {
- walk_pat(self, pat);
- }
- #[cfg(feature = "full")]
- fn visit_fn_decl(&mut self, fn_decl: &FnDecl) {
- walk_fn_decl(self, fn_decl);
- }
- #[cfg(feature = "full")]
- fn visit_trait_item(&mut self, trait_item: &TraitItem) {
- walk_trait_item(self, trait_item);
- }
- #[cfg(feature = "full")]
- fn visit_impl_item(&mut self, impl_item: &ImplItem) {
- walk_impl_item(self, impl_item);
- }
- #[cfg(feature = "full")]
- fn visit_method_sig(&mut self, method_sig: &MethodSig) {
- walk_method_sig(self, method_sig);
- }
- #[cfg(feature = "full")]
- fn visit_stmt(&mut self, stmt: &Stmt) {
- walk_stmt(self, stmt);
- }
- #[cfg(feature = "full")]
- fn visit_local(&mut self, local: &Local) {
- walk_local(self, local);
- }
- #[cfg(feature = "full")]
- fn visit_view_path(&mut self, view_path: &ViewPath) {
- walk_view_path(self, view_path);
- }
-}
-
-macro_rules! walk_list {
- ($visitor:expr, $method:ident, $list:expr $(, $extra_args:expr)*) => {
- for elem in $list {
- $visitor.$method(elem $(, $extra_args)*)
- }
- };
-}
-
-pub fn walk_opt_ident<V: Visitor>(visitor: &mut V, opt_ident: &Option<Ident>) {
- if let Some(ref ident) = *opt_ident {
- visitor.visit_ident(ident);
- }
-}
-
-pub fn walk_lifetime_def<V: Visitor>(visitor: &mut V, lifetime_def: &LifetimeDef) {
- visitor.visit_lifetime(&lifetime_def.lifetime);
- walk_list!(visitor, visit_lifetime, &lifetime_def.bounds);
-}
-
-pub fn walk_poly_trait_ref<V>(visitor: &mut V, trait_ref: &PolyTraitRef, _: &TraitBoundModifier)
- where V: Visitor
-{
- walk_list!(visitor, visit_lifetime_def, &trait_ref.bound_lifetimes);
- visitor.visit_path(&trait_ref.trait_ref);
-}
-
-pub fn walk_derive_input<V: Visitor>(visitor: &mut V, derive_input: &DeriveInput) {
- visitor.visit_ident(&derive_input.ident);
- visitor.visit_generics(&derive_input.generics);
- match derive_input.body {
- Body::Enum(ref variants) => {
- walk_list!(visitor, visit_variant, variants, &derive_input.generics);
- }
- Body::Struct(ref variant_data) => {
- visitor.visit_variant_data(variant_data, &derive_input.ident, &derive_input.generics);
- }
- }
- walk_list!(visitor, visit_attribute, &derive_input.attrs);
-}
-
-pub fn walk_variant<V>(visitor: &mut V, variant: &Variant, generics: &Generics)
- where V: Visitor
-{
- visitor.visit_ident(&variant.ident);
- visitor.visit_variant_data(&variant.data, &variant.ident, generics);
- walk_list!(visitor, visit_attribute, &variant.attrs);
-}
-
-pub fn walk_ty<V: Visitor>(visitor: &mut V, ty: &Ty) {
- match *ty {
- Ty::Slice(ref inner) |
- Ty::Paren(ref inner) => visitor.visit_ty(inner),
- Ty::Ptr(ref mutable_type) => visitor.visit_ty(&mutable_type.ty),
- Ty::Rptr(ref opt_lifetime, ref mutable_type) => {
- walk_list!(visitor, visit_lifetime, opt_lifetime);
- visitor.visit_ty(&mutable_type.ty)
- }
- Ty::Never | Ty::Infer => {}
- Ty::Tup(ref tuple_element_types) => {
- walk_list!(visitor, visit_ty, tuple_element_types);
- }
- Ty::BareFn(ref bare_fn) => {
- walk_list!(visitor, visit_lifetime_def, &bare_fn.lifetimes);
- for argument in &bare_fn.inputs {
- walk_opt_ident(visitor, &argument.name);
- visitor.visit_ty(&argument.ty)
- }
- visitor.visit_fn_ret_ty(&bare_fn.output)
- }
- Ty::Path(ref maybe_qself, ref path) => {
- if let Some(ref qself) = *maybe_qself {
- visitor.visit_ty(&qself.ty);
- }
- visitor.visit_path(path);
- }
- Ty::Array(ref inner, ref len) => {
- visitor.visit_ty(inner);
- visitor.visit_const_expr(len);
- }
- Ty::TraitObject(ref bounds) |
- Ty::ImplTrait(ref bounds) => {
- walk_list!(visitor, visit_ty_param_bound, bounds);
- }
- Ty::Mac(ref mac) => {
- visitor.visit_mac(mac);
- }
- }
-}
-
-pub fn walk_path<V: Visitor>(visitor: &mut V, path: &Path) {
- for segment in &path.segments {
- visitor.visit_path_segment(segment);
- }
-}
-
-pub fn walk_path_segment<V: Visitor>(visitor: &mut V, segment: &PathSegment) {
- visitor.visit_ident(&segment.ident);
- visitor.visit_path_parameters(&segment.parameters);
-}
-
-pub fn walk_path_parameters<V>(visitor: &mut V, path_parameters: &PathParameters)
- where V: Visitor
-{
- match *path_parameters {
- PathParameters::AngleBracketed(ref data) => {
- walk_list!(visitor, visit_ty, &data.types);
- walk_list!(visitor, visit_lifetime, &data.lifetimes);
- walk_list!(visitor, visit_assoc_type_binding, &data.bindings);
- }
- PathParameters::Parenthesized(ref data) => {
- walk_list!(visitor, visit_ty, &data.inputs);
- walk_list!(visitor, visit_ty, &data.output);
- }
- }
-}
-
-pub fn walk_assoc_type_binding<V: Visitor>(visitor: &mut V, type_binding: &TypeBinding) {
- visitor.visit_ident(&type_binding.ident);
- visitor.visit_ty(&type_binding.ty);
-}
-
-pub fn walk_ty_param_bound<V: Visitor>(visitor: &mut V, bound: &TyParamBound) {
- match *bound {
- TyParamBound::Trait(ref ty, ref modifier) => {
- visitor.visit_poly_trait_ref(ty, modifier);
- }
- TyParamBound::Region(ref lifetime) => {
- visitor.visit_lifetime(lifetime);
- }
- }
-}
-
-pub fn walk_generics<V: Visitor>(visitor: &mut V, generics: &Generics) {
- for param in &generics.ty_params {
- visitor.visit_ident(¶m.ident);
- walk_list!(visitor, visit_ty_param_bound, ¶m.bounds);
- walk_list!(visitor, visit_ty, ¶m.default);
- }
- walk_list!(visitor, visit_lifetime_def, &generics.lifetimes);
- for predicate in &generics.where_clause.predicates {
- match *predicate {
- WherePredicate::BoundPredicate(WhereBoundPredicate { ref bounded_ty,
- ref bounds,
- ref bound_lifetimes,
- .. }) => {
- visitor.visit_ty(bounded_ty);
- walk_list!(visitor, visit_ty_param_bound, bounds);
- walk_list!(visitor, visit_lifetime_def, bound_lifetimes);
- }
- WherePredicate::RegionPredicate(WhereRegionPredicate { ref lifetime,
- ref bounds,
- .. }) => {
- visitor.visit_lifetime(lifetime);
- walk_list!(visitor, visit_lifetime, bounds);
- }
- WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty, .. }) => {
- visitor.visit_ty(lhs_ty);
- visitor.visit_ty(rhs_ty);
- }
- }
- }
-}
-
-pub fn walk_fn_ret_ty<V: Visitor>(visitor: &mut V, ret_ty: &FunctionRetTy) {
- if let FunctionRetTy::Ty(ref output_ty) = *ret_ty {
- visitor.visit_ty(output_ty)
- }
-}
-
-pub fn walk_variant_data<V: Visitor>(visitor: &mut V, data: &VariantData) {
- walk_list!(visitor, visit_field, data.fields());
-}
-
-pub fn walk_field<V: Visitor>(visitor: &mut V, field: &Field) {
- walk_opt_ident(visitor, &field.ident);
- visitor.visit_ty(&field.ty);
- walk_list!(visitor, visit_attribute, &field.attrs);
-}
-
-pub fn walk_const_expr<V: Visitor>(visitor: &mut V, len: &ConstExpr) {
- match *len {
- ConstExpr::Call(ref function, ref args) => {
- visitor.visit_const_expr(function);
- walk_list!(visitor, visit_const_expr, args);
- }
- ConstExpr::Binary(_op, ref left, ref right) => {
- visitor.visit_const_expr(left);
- visitor.visit_const_expr(right);
- }
- ConstExpr::Unary(_op, ref v) => {
- visitor.visit_const_expr(v);
- }
- ConstExpr::Lit(ref lit) => {
- visitor.visit_lit(lit);
- }
- ConstExpr::Cast(ref expr, ref ty) => {
- visitor.visit_const_expr(expr);
- visitor.visit_ty(ty);
- }
- ConstExpr::Path(ref path) => {
- visitor.visit_path(path);
- }
- ConstExpr::Index(ref expr, ref index) => {
- visitor.visit_const_expr(expr);
- visitor.visit_const_expr(index);
- }
- ConstExpr::Paren(ref expr) => {
- visitor.visit_const_expr(expr);
- }
- ConstExpr::Other(ref other) => {
- #[cfg(feature = "full")]
- fn walk_other<V: Visitor>(visitor: &mut V, other: &Expr) {
- visitor.visit_expr(other);
- }
- #[cfg(not(feature = "full"))]
- fn walk_other<V: Visitor>(_: &mut V, _: &super::constant::Other) {}
- walk_other(visitor, other);
- }
- }
-}
-
-pub fn walk_mac<V: Visitor>(visitor: &mut V, mac: &Mac) {
- visitor.visit_path(&mac.path);
-}
-
-#[cfg(feature = "full")]
-pub fn walk_crate<V: Visitor>(visitor: &mut V, _crate: &Crate) {
- walk_list!(visitor, visit_attribute, &_crate.attrs);
- walk_list!(visitor, visit_item, &_crate.items);
-}
-
-#[cfg(feature = "full")]
-pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
- visitor.visit_ident(&item.ident);
- walk_list!(visitor, visit_attribute, &item.attrs);
- match item.node {
- ItemKind::ExternCrate(ref ident) => {
- walk_opt_ident(visitor, ident);
- }
- ItemKind::Use(ref view_path) => {
- visitor.visit_view_path(view_path);
- }
- ItemKind::Static(ref ty, _, ref expr) |
- ItemKind::Const(ref ty, ref expr) => {
- visitor.visit_ty(ty);
- visitor.visit_expr(expr);
- }
- ItemKind::Fn(ref decl, _, _, _, ref generics, ref body) => {
- visitor.visit_fn_decl(decl);
- visitor.visit_generics(generics);
- walk_list!(visitor, visit_stmt, &body.stmts);
- }
- ItemKind::Mod(ref maybe_items) => {
- if let Some(ref items) = *maybe_items {
- walk_list!(visitor, visit_item, items);
- }
- }
- ItemKind::ForeignMod(ref foreign_mod) => {
- walk_list!(visitor, visit_foreign_item, &foreign_mod.items);
- }
- ItemKind::Ty(ref ty, ref generics) => {
- visitor.visit_ty(ty);
- visitor.visit_generics(generics);
- }
- ItemKind::Enum(ref variant, ref generics) => {
- walk_list!(visitor, visit_variant, variant, generics);
- }
- ItemKind::Struct(ref variant_data, ref generics) |
- ItemKind::Union(ref variant_data, ref generics) => {
- visitor.visit_variant_data(variant_data, &item.ident, generics);
- }
- ItemKind::Trait(_, ref generics, ref bounds, ref trait_items) => {
- visitor.visit_generics(generics);
- walk_list!(visitor, visit_ty_param_bound, bounds);
- walk_list!(visitor, visit_trait_item, trait_items);
- }
- ItemKind::DefaultImpl(_, ref path) => {
- visitor.visit_path(path);
- }
- ItemKind::Impl(_, _, ref generics, ref maybe_path, ref ty, ref impl_items) => {
- visitor.visit_generics(generics);
- if let Some(ref path) = *maybe_path {
- visitor.visit_path(path);
- }
- visitor.visit_ty(ty);
- walk_list!(visitor, visit_impl_item, impl_items);
- }
- ItemKind::Mac(ref mac) => visitor.visit_mac(mac),
- }
-}
-
-#[cfg(feature = "full")]
-#[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
-pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr) {
- walk_list!(visitor, visit_attribute, &expr.attrs);
- match expr.node {
- ExprKind::InPlace(ref place, ref value) => {
- visitor.visit_expr(place);
- visitor.visit_expr(value);
- }
- ExprKind::Call(ref callee, ref args) => {
- visitor.visit_expr(callee);
- walk_list!(visitor, visit_expr, args);
- }
- ExprKind::MethodCall(ref name, ref ty_args, ref args) => {
- visitor.visit_ident(name);
- walk_list!(visitor, visit_ty, ty_args);
- walk_list!(visitor, visit_expr, args);
- }
- ExprKind::Array(ref exprs) |
- ExprKind::Tup(ref exprs) => {
- walk_list!(visitor, visit_expr, exprs);
- }
- ExprKind::Unary(_, ref operand) => {
- visitor.visit_expr(operand);
- }
- ExprKind::Lit(ref lit) => {
- visitor.visit_lit(lit);
- }
- ExprKind::Cast(ref expr, ref ty) |
- ExprKind::Type(ref expr, ref ty) => {
- visitor.visit_expr(expr);
- visitor.visit_ty(ty);
- }
- ExprKind::If(ref cond, ref cons, ref maybe_alt) => {
- visitor.visit_expr(cond);
- walk_list!(visitor, visit_stmt, &cons.stmts);
- if let Some(ref alt) = *maybe_alt {
- visitor.visit_expr(alt);
- }
- }
- ExprKind::IfLet(ref pat, ref cond, ref cons, ref maybe_alt) => {
- visitor.visit_pat(pat);
- visitor.visit_expr(cond);
- walk_list!(visitor, visit_stmt, &cons.stmts);
- if let Some(ref alt) = *maybe_alt {
- visitor.visit_expr(alt);
- }
- }
- ExprKind::While(ref cond, ref body, ref label) => {
- visitor.visit_expr(cond);
- walk_list!(visitor, visit_stmt, &body.stmts);
- walk_opt_ident(visitor, label);
- }
- ExprKind::WhileLet(ref pat, ref cond, ref body, ref label) => {
- visitor.visit_pat(pat);
- visitor.visit_expr(cond);
- walk_list!(visitor, visit_stmt, &body.stmts);
- walk_opt_ident(visitor, label);
- }
- ExprKind::ForLoop(ref pat, ref expr, ref body, ref label) => {
- visitor.visit_pat(pat);
- visitor.visit_expr(expr);
- walk_list!(visitor, visit_stmt, &body.stmts);
- walk_opt_ident(visitor, label);
- }
- ExprKind::Loop(ref body, ref label) => {
- walk_list!(visitor, visit_stmt, &body.stmts);
- walk_opt_ident(visitor, label);
- }
- ExprKind::Match(ref expr, ref arms) => {
- visitor.visit_expr(expr);
- for &Arm { ref attrs, ref pats, ref guard, ref body } in arms {
- walk_list!(visitor, visit_attribute, attrs);
- walk_list!(visitor, visit_pat, pats);
- if let Some(ref guard) = *guard {
- visitor.visit_expr(guard);
- }
- visitor.visit_expr(body);
- }
- }
- ExprKind::Closure(_, ref decl, ref expr) => {
- visitor.visit_fn_decl(decl);
- visitor.visit_expr(expr);
- }
- ExprKind::Block(_, ref block) => {
- walk_list!(visitor, visit_stmt, &block.stmts);
- }
- ExprKind::Binary(_, ref lhs, ref rhs) |
- ExprKind::Assign(ref lhs, ref rhs) |
- ExprKind::AssignOp(_, ref lhs, ref rhs) => {
- visitor.visit_expr(lhs);
- visitor.visit_expr(rhs);
- }
- ExprKind::Field(ref obj, ref field) => {
- visitor.visit_expr(obj);
- visitor.visit_ident(field);
- }
- ExprKind::TupField(ref obj, _) => {
- visitor.visit_expr(obj);
- }
- ExprKind::Index(ref obj, ref idx) => {
- visitor.visit_expr(obj);
- visitor.visit_expr(idx);
- }
- ExprKind::Range(ref maybe_start, ref maybe_end, _) => {
- if let Some(ref start) = *maybe_start {
- visitor.visit_expr(start);
- }
- if let Some(ref end) = *maybe_end {
- visitor.visit_expr(end);
- }
- }
- ExprKind::Path(ref maybe_qself, ref path) => {
- if let Some(ref qself) = *maybe_qself {
- visitor.visit_ty(&qself.ty);
- }
- visitor.visit_path(path);
- }
- ExprKind::Break(ref maybe_label, ref maybe_expr) => {
- walk_opt_ident(visitor, maybe_label);
- if let Some(ref expr) = *maybe_expr {
- visitor.visit_expr(expr);
- }
- }
- ExprKind::Continue(ref maybe_label) => {
- walk_opt_ident(visitor, maybe_label);
- }
- ExprKind::Ret(ref maybe_expr) => {
- if let Some(ref expr) = *maybe_expr {
- visitor.visit_expr(expr);
- }
- }
- ExprKind::Mac(ref mac) => {
- visitor.visit_mac(mac);
- }
- ExprKind::Struct(ref path, ref fields, ref maybe_base) => {
- visitor.visit_path(path);
- for &FieldValue { ref ident, ref expr, .. } in fields {
- visitor.visit_ident(ident);
- visitor.visit_expr(expr);
- }
- if let Some(ref base) = *maybe_base {
- visitor.visit_expr(base);
- }
- }
- ExprKind::Repeat(ref value, ref times) => {
- visitor.visit_expr(value);
- visitor.visit_expr(times);
- }
- ExprKind::Box(ref expr) |
- ExprKind::AddrOf(_, ref expr) |
- ExprKind::Paren(ref expr) |
- ExprKind::Try(ref expr) => {
- visitor.visit_expr(expr);
- }
- }
-}
-
-#[cfg(feature = "full")]
-pub fn walk_foreign_item<V: Visitor>(visitor: &mut V, foreign_item: &ForeignItem) {
- visitor.visit_ident(&foreign_item.ident);
- walk_list!(visitor, visit_attribute, &foreign_item.attrs);
- match foreign_item.node {
- ForeignItemKind::Fn(ref decl, ref generics) => {
- visitor.visit_fn_decl(decl);
- visitor.visit_generics(generics);
- }
- ForeignItemKind::Static(ref ty, _) => {
- visitor.visit_ty(ty);
- }
- }
-}
-
-#[cfg(feature = "full")]
-pub fn walk_pat<V: Visitor>(visitor: &mut V, pat: &Pat) {
- match *pat {
- Pat::Wild => {}
- Pat::Ident(_, ref ident, ref maybe_pat) => {
- visitor.visit_ident(ident);
- if let Some(ref pat) = *maybe_pat {
- visitor.visit_pat(pat);
- }
- }
- Pat::Struct(ref path, ref field_pats, _) => {
- visitor.visit_path(path);
- for &FieldPat { ref ident, ref pat, .. } in field_pats {
- visitor.visit_ident(ident);
- visitor.visit_pat(pat);
- }
- }
- Pat::TupleStruct(ref path, ref pats, _) => {
- visitor.visit_path(path);
- walk_list!(visitor, visit_pat, pats);
- }
- Pat::Path(ref maybe_qself, ref path) => {
- if let Some(ref qself) = *maybe_qself {
- visitor.visit_ty(&qself.ty);
- }
- visitor.visit_path(path);
- }
- Pat::Tuple(ref pats, _) => {
- walk_list!(visitor, visit_pat, pats);
- }
- Pat::Box(ref pat) |
- Pat::Ref(ref pat, _) => {
- visitor.visit_pat(pat);
- }
- Pat::Lit(ref expr) => {
- visitor.visit_expr(expr);
- }
- Pat::Range(ref start, ref end) => {
- visitor.visit_expr(start);
- visitor.visit_expr(end);
- }
- Pat::Slice(ref start, ref maybe_mid, ref end) => {
- walk_list!(visitor, visit_pat, start);
- if let Some(ref mid) = *maybe_mid {
- visitor.visit_pat(mid);
- }
- walk_list!(visitor, visit_pat, end);
- }
- Pat::Mac(ref mac) => {
- visitor.visit_mac(mac);
- }
- }
-}
-
-#[cfg(feature = "full")]
-pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, fn_decl: &FnDecl) {
- for input in &fn_decl.inputs {
- match *input {
- FnArg::SelfRef(_, _) |
- FnArg::SelfValue(_) => {}
- FnArg::Captured(ref pat, ref ty) => {
- visitor.visit_pat(pat);
- visitor.visit_ty(ty);
- }
- FnArg::Ignored(ref ty) => {
- visitor.visit_ty(ty);
- }
- }
- }
- visitor.visit_fn_ret_ty(&fn_decl.output);
-}
-
-#[cfg(feature = "full")]
-pub fn walk_trait_item<V: Visitor>(visitor: &mut V, trait_item: &TraitItem) {
- visitor.visit_ident(&trait_item.ident);
- walk_list!(visitor, visit_attribute, &trait_item.attrs);
- match trait_item.node {
- TraitItemKind::Const(ref ty, ref maybe_expr) => {
- visitor.visit_ty(ty);
- if let Some(ref expr) = *maybe_expr {
- visitor.visit_expr(expr);
- }
- }
- TraitItemKind::Method(ref method_sig, ref maybe_block) => {
- visitor.visit_method_sig(method_sig);
- if let Some(ref block) = *maybe_block {
- walk_list!(visitor, visit_stmt, &block.stmts);
- }
- }
- TraitItemKind::Type(ref bounds, ref maybe_ty) => {
- walk_list!(visitor, visit_ty_param_bound, bounds);
- if let Some(ref ty) = *maybe_ty {
- visitor.visit_ty(ty);
- }
- }
- TraitItemKind::Macro(ref mac) => {
- visitor.visit_mac(mac);
- }
- }
-}
-
-#[cfg(feature = "full")]
-pub fn walk_impl_item<V: Visitor>(visitor: &mut V, impl_item: &ImplItem) {
- visitor.visit_ident(&impl_item.ident);
- walk_list!(visitor, visit_attribute, &impl_item.attrs);
- match impl_item.node {
- ImplItemKind::Const(ref ty, ref expr) => {
- visitor.visit_ty(ty);
- visitor.visit_expr(expr);
- }
- ImplItemKind::Method(ref method_sig, ref block) => {
- visitor.visit_method_sig(method_sig);
- walk_list!(visitor, visit_stmt, &block.stmts);
- }
- ImplItemKind::Type(ref ty) => {
- visitor.visit_ty(ty);
- }
- ImplItemKind::Macro(ref mac) => {
- visitor.visit_mac(mac);
- }
- }
-}
-
-#[cfg(feature = "full")]
-pub fn walk_method_sig<V: Visitor>(visitor: &mut V, method_sig: &MethodSig) {
- visitor.visit_fn_decl(&method_sig.decl);
- visitor.visit_generics(&method_sig.generics);
-}
-
-#[cfg(feature = "full")]
-pub fn walk_stmt<V: Visitor>(visitor: &mut V, stmt: &Stmt) {
- match *stmt {
- Stmt::Local(ref local) => {
- visitor.visit_local(local);
- }
- Stmt::Item(ref item) => {
- visitor.visit_item(item);
- }
- Stmt::Expr(ref expr) |
- Stmt::Semi(ref expr) => {
- visitor.visit_expr(expr);
- }
- Stmt::Mac(ref details) => {
- let (ref mac, _, ref attrs) = **details;
- visitor.visit_mac(mac);
- walk_list!(visitor, visit_attribute, attrs);
- }
- }
-}
-
-#[cfg(feature = "full")]
-pub fn walk_local<V: Visitor>(visitor: &mut V, local: &Local) {
- visitor.visit_pat(&local.pat);
- if let Some(ref ty) = local.ty {
- visitor.visit_ty(ty);
- }
- if let Some(ref init) = local.init {
- visitor.visit_expr(init);
- }
- walk_list!(visitor, visit_attribute, &local.attrs);
-}
-
-#[cfg(feature = "full")]
-pub fn walk_view_path<V: Visitor>(visitor: &mut V, view_path: &ViewPath) {
- match *view_path {
- ViewPath::Simple(ref path, ref maybe_ident) => {
- visitor.visit_path(path);
- walk_opt_ident(visitor, maybe_ident);
- }
- ViewPath::Glob(ref path) => {
- visitor.visit_path(path);
- }
- ViewPath::List(ref path, ref items) => {
- visitor.visit_path(path);
- for &PathListItem { ref name, ref rename } in items {
- visitor.visit_ident(name);
- walk_opt_ident(visitor, rename);
- }
- }
- }
-}
copy from third_party/rust/syn/.cargo-checksum.json
copy to third_party/rust/syn-0.12.12/.cargo-checksum.json
copy from third_party/rust/syn/Cargo.toml
copy to third_party/rust/syn-0.12.12/Cargo.toml
rename from third_party/rust/unicode-xid-0.0.4/LICENSE-APACHE
rename to third_party/rust/syn-0.12.12/LICENSE-APACHE
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2018 Syn Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
copy from third_party/rust/syn/README.md
copy to third_party/rust/syn-0.12.12/README.md
copy from third_party/rust/syn/src/attr.rs
copy to third_party/rust/syn-0.12.12/src/attr.rs
copy from third_party/rust/syn/src/buffer.rs
copy to third_party/rust/syn-0.12.12/src/buffer.rs
copy from third_party/rust/syn/src/data.rs
copy to third_party/rust/syn-0.12.12/src/data.rs
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/derive.rs
@@ -0,0 +1,210 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+use punctuated::Punctuated;
+
+ast_struct! {
+ /// Data structure sent to a `proc_macro_derive` macro.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` feature.*
+ pub struct DeriveInput {
+ /// Attributes tagged on the whole struct or enum.
+ pub attrs: Vec<Attribute>,
+
+ /// Visibility of the struct or enum.
+ pub vis: Visibility,
+
+ /// Name of the struct or enum.
+ pub ident: Ident,
+
+ /// Generics required to complete the definition.
+ pub generics: Generics,
+
+ /// Data within the struct or enum.
+ pub data: Data,
+ }
+}
+
+ast_enum_of_structs! {
+ /// The storage of a struct, enum or union data structure.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` feature.*
+ ///
+ /// # Syntax tree enum
+ ///
+ /// This type is a [syntax tree enum].
+ ///
+ /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
+ pub enum Data {
+ /// A struct input to a `proc_macro_derive` macro.
+ ///
+ /// *This type is available if Syn is built with the `"derive"`
+ /// feature.*
+ pub Struct(DataStruct {
+ pub struct_token: Token![struct],
+ pub fields: Fields,
+ pub semi_token: Option<Token![;]>,
+ }),
+
+ /// An enum input to a `proc_macro_derive` macro.
+ ///
+ /// *This type is available if Syn is built with the `"derive"`
+ /// feature.*
+ pub Enum(DataEnum {
+ pub enum_token: Token![enum],
+ pub brace_token: token::Brace,
+ pub variants: Punctuated<Variant, Token![,]>,
+ }),
+
+ /// A tagged union input to a `proc_macro_derive` macro.
+ ///
+ /// *This type is available if Syn is built with the `"derive"`
+ /// feature.*
+ pub Union(DataUnion {
+ pub union_token: Token![union],
+ pub fields: FieldsNamed,
+ }),
+ }
+
+ do_not_generate_to_tokens
+}
+
+#[cfg(feature = "parsing")]
+pub mod parsing {
+ use super::*;
+
+ use synom::Synom;
+
+ impl Synom for DeriveInput {
+ named!(parse -> Self, do_parse!(
+ attrs: many0!(Attribute::parse_outer) >>
+ vis: syn!(Visibility) >>
+ which: alt!(
+ keyword!(struct) => { Ok }
+ |
+ keyword!(enum) => { Err }
+ ) >>
+ id: syn!(Ident) >>
+ generics: syn!(Generics) >>
+ item: switch!(value!(which),
+ Ok(s) => map!(data_struct, move |(wh, fields, semi)| DeriveInput {
+ ident: id,
+ vis: vis,
+ attrs: attrs,
+ generics: Generics {
+ where_clause: wh,
+ .. generics
+ },
+ data: Data::Struct(DataStruct {
+ struct_token: s,
+ fields: fields,
+ semi_token: semi,
+ }),
+ })
+ |
+ Err(e) => map!(data_enum, move |(wh, brace, variants)| DeriveInput {
+ ident: id,
+ vis: vis,
+ attrs: attrs,
+ generics: Generics {
+ where_clause: wh,
+ .. generics
+ },
+ data: Data::Enum(DataEnum {
+ variants: variants,
+ brace_token: brace,
+ enum_token: e,
+ }),
+ })
+ ) >>
+ (item)
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("derive input")
+ }
+ }
+
+ named!(data_struct -> (Option<WhereClause>, Fields, Option<Token![;]>), alt!(
+ do_parse!(
+ wh: option!(syn!(WhereClause)) >>
+ fields: syn!(FieldsNamed) >>
+ (wh, Fields::Named(fields), None)
+ )
+ |
+ do_parse!(
+ fields: syn!(FieldsUnnamed) >>
+ wh: option!(syn!(WhereClause)) >>
+ semi: punct!(;) >>
+ (wh, Fields::Unnamed(fields), Some(semi))
+ )
+ |
+ do_parse!(
+ wh: option!(syn!(WhereClause)) >>
+ semi: punct!(;) >>
+ (wh, Fields::Unit, Some(semi))
+ )
+ ));
+
+ named!(data_enum -> (Option<WhereClause>, token::Brace, Punctuated<Variant, Token![,]>), do_parse!(
+ wh: option!(syn!(WhereClause)) >>
+ data: braces!(Punctuated::parse_terminated) >>
+ (wh, data.0, data.1)
+ ));
+}
+
+#[cfg(feature = "printing")]
+mod printing {
+ use super::*;
+ use attr::FilterAttrs;
+ use quote::{ToTokens, Tokens};
+
+ impl ToTokens for DeriveInput {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ for attr in self.attrs.outer() {
+ attr.to_tokens(tokens);
+ }
+ self.vis.to_tokens(tokens);
+ match self.data {
+ Data::Struct(ref d) => d.struct_token.to_tokens(tokens),
+ Data::Enum(ref d) => d.enum_token.to_tokens(tokens),
+ Data::Union(ref d) => d.union_token.to_tokens(tokens),
+ }
+ self.ident.to_tokens(tokens);
+ self.generics.to_tokens(tokens);
+ match self.data {
+ Data::Struct(ref data) => match data.fields {
+ Fields::Named(ref fields) => {
+ self.generics.where_clause.to_tokens(tokens);
+ fields.to_tokens(tokens);
+ }
+ Fields::Unnamed(ref fields) => {
+ fields.to_tokens(tokens);
+ self.generics.where_clause.to_tokens(tokens);
+ TokensOrDefault(&data.semi_token).to_tokens(tokens);
+ }
+ Fields::Unit => {
+ self.generics.where_clause.to_tokens(tokens);
+ TokensOrDefault(&data.semi_token).to_tokens(tokens);
+ }
+ },
+ Data::Enum(ref data) => {
+ self.generics.where_clause.to_tokens(tokens);
+ data.brace_token.surround(tokens, |tokens| {
+ data.variants.to_tokens(tokens);
+ });
+ }
+ Data::Union(ref data) => {
+ self.generics.where_clause.to_tokens(tokens);
+ data.fields.to_tokens(tokens);
+ }
+ }
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/error.rs
@@ -0,0 +1,60 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::error::Error;
+use buffer::Cursor;
+use std::fmt::{self, Display};
+
+/// The result of a `Synom` parser.
+///
+/// Refer to the [module documentation] for details about parsing in Syn.
+///
+/// [module documentation]: index.html
+///
+/// *This type is available if Syn is built with the `"parsing"` feature.*
+pub type PResult<'a, O> = Result<(O, Cursor<'a>), ParseError>;
+
+/// An error with a default error message.
+///
+/// NOTE: We should provide better error messages in the future.
+pub fn parse_error<O>() -> PResult<'static, O> {
+ Err(ParseError(None))
+}
+
+/// Error returned when a `Synom` parser cannot parse the input tokens.
+///
+/// Refer to the [module documentation] for details about parsing in Syn.
+///
+/// [module documentation]: index.html
+///
+/// *This type is available if Syn is built with the `"parsing"` feature.*
+#[derive(Debug)]
+pub struct ParseError(Option<String>);
+
+impl Error for ParseError {
+ fn description(&self) -> &str {
+ match self.0 {
+ Some(ref desc) => desc,
+ None => "failed to parse",
+ }
+ }
+}
+
+impl Display for ParseError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(self.description(), f)
+ }
+}
+
+impl ParseError {
+ // For syn use only. Not public API.
+ #[doc(hidden)]
+ pub fn new<T: Into<String>>(msg: T) -> Self {
+ ParseError(Some(msg.into()))
+ }
+}
copy from third_party/rust/syn/src/expr.rs
copy to third_party/rust/syn-0.12.12/src/expr.rs
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/file.rs
@@ -0,0 +1,122 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+
+ast_struct! {
+ /// A complete file of Rust source code.
+ ///
+ /// *This type is available if Syn is built with the `"full"` feature.*
+ ///
+ /// # Example
+ ///
+ /// Parse a Rust source file into a `syn::File` and print out a debug
+ /// representation of the syntax tree.
+ ///
+ /// ```
+ /// extern crate syn;
+ ///
+ /// use std::env;
+ /// use std::fs::File;
+ /// use std::io::Read;
+ /// use std::process;
+ ///
+ /// fn main() {
+ /// # }
+ /// #
+ /// # fn fake_main() {
+ /// let mut args = env::args();
+ /// let _ = args.next(); // executable name
+ ///
+ /// let filename = match (args.next(), args.next()) {
+ /// (Some(filename), None) => filename,
+ /// _ => {
+ /// eprintln!("Usage: dump-syntax path/to/filename.rs");
+ /// process::exit(1);
+ /// }
+ /// };
+ ///
+ /// let mut file = File::open(&filename).expect("Unable to open file");
+ ///
+ /// let mut src = String::new();
+ /// file.read_to_string(&mut src).expect("Unable to read file");
+ ///
+ /// let syntax = syn::parse_file(&src).expect("Unable to parse file");
+ /// println!("{:#?}", syntax);
+ /// }
+ /// ```
+ ///
+ /// Running with its own source code as input, this program prints output
+ /// that begins with:
+ ///
+ /// ```text
+ /// File {
+ /// shebang: None,
+ /// attrs: [],
+ /// items: [
+ /// ExternCrate(
+ /// ItemExternCrate {
+ /// attrs: [],
+ /// vis: Inherited,
+ /// extern_token: Extern,
+ /// crate_token: Crate,
+ /// ident: Ident {
+ /// term: Term(
+ /// "syn"
+ /// ),
+ /// span: Span
+ /// },
+ /// rename: None,
+ /// semi_token: Semi
+ /// }
+ /// ),
+ /// ...
+ /// ```
+ pub struct File {
+ pub shebang: Option<String>,
+ pub attrs: Vec<Attribute>,
+ pub items: Vec<Item>,
+ }
+}
+
+#[cfg(feature = "parsing")]
+pub mod parsing {
+ use super::*;
+
+ use synom::Synom;
+
+ impl Synom for File {
+ named!(parse -> Self, do_parse!(
+ attrs: many0!(Attribute::parse_inner) >>
+ items: many0!(Item::parse) >>
+ (File {
+ shebang: None,
+ attrs: attrs,
+ items: items,
+ })
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("crate")
+ }
+ }
+}
+
+#[cfg(feature = "printing")]
+mod printing {
+ use super::*;
+ use attr::FilterAttrs;
+ use quote::{ToTokens, Tokens};
+
+ impl ToTokens for File {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ tokens.append_all(self.attrs.inner());
+ tokens.append_all(&self.items);
+ }
+ }
+}
copy from third_party/rust/syn/src/gen/fold.rs
copy to third_party/rust/syn-0.12.12/src/gen/fold.rs
copy from third_party/rust/syn/src/gen/visit.rs
copy to third_party/rust/syn-0.12.12/src/gen/visit.rs
copy from third_party/rust/syn/src/gen/visit_mut.rs
copy to third_party/rust/syn-0.12.12/src/gen/visit_mut.rs
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/gen_helper.rs
@@ -0,0 +1,165 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature = "fold")]
+pub mod fold {
+ use punctuated::{Pair, Punctuated};
+ use fold::Fold;
+ use proc_macro2::Span;
+
+ pub trait FoldHelper {
+ type Item;
+ fn lift<F>(self, f: F) -> Self
+ where
+ F: FnMut(Self::Item) -> Self::Item;
+ }
+
+ impl<T> FoldHelper for Vec<T> {
+ type Item = T;
+ fn lift<F>(self, f: F) -> Self
+ where
+ F: FnMut(Self::Item) -> Self::Item,
+ {
+ self.into_iter().map(f).collect()
+ }
+ }
+
+ impl<T, U> FoldHelper for Punctuated<T, U> {
+ type Item = T;
+ fn lift<F>(self, mut f: F) -> Self
+ where
+ F: FnMut(Self::Item) -> Self::Item,
+ {
+ self.into_pairs()
+ .map(Pair::into_tuple)
+ .map(|(t, u)| Pair::new(f(t), u))
+ .collect()
+ }
+ }
+
+ pub fn tokens_helper<F: Fold + ?Sized, S: Spans>(folder: &mut F, spans: &S) -> S {
+ spans.fold(folder)
+ }
+
+ pub trait Spans {
+ fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self;
+ }
+
+ impl Spans for Span {
+ fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
+ folder.fold_span(*self)
+ }
+ }
+
+ impl Spans for [Span; 1] {
+ fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
+ [folder.fold_span(self[0])]
+ }
+ }
+
+ impl Spans for [Span; 2] {
+ fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
+ [folder.fold_span(self[0]), folder.fold_span(self[1])]
+ }
+ }
+
+ impl Spans for [Span; 3] {
+ fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self {
+ [
+ folder.fold_span(self[0]),
+ folder.fold_span(self[1]),
+ folder.fold_span(self[2]),
+ ]
+ }
+ }
+}
+
+#[cfg(feature = "visit")]
+pub mod visit {
+ use proc_macro2::Span;
+ use visit::Visit;
+
+ pub fn tokens_helper<'ast, V: Visit<'ast> + ?Sized, S: Spans>(
+ visitor: &mut V,
+ spans: &'ast S,
+ ) {
+ spans.visit(visitor);
+ }
+
+ pub trait Spans {
+ fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V);
+ }
+
+ impl Spans for Span {
+ fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
+ visitor.visit_span(self);
+ }
+ }
+
+ impl Spans for [Span; 1] {
+ fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
+ visitor.visit_span(&self[0]);
+ }
+ }
+
+ impl Spans for [Span; 2] {
+ fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
+ visitor.visit_span(&self[0]);
+ visitor.visit_span(&self[1]);
+ }
+ }
+
+ impl Spans for [Span; 3] {
+ fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) {
+ visitor.visit_span(&self[0]);
+ visitor.visit_span(&self[1]);
+ visitor.visit_span(&self[2]);
+ }
+ }
+}
+
+#[cfg(feature = "visit-mut")]
+pub mod visit_mut {
+ use proc_macro2::Span;
+ use visit_mut::VisitMut;
+
+ pub fn tokens_helper<V: VisitMut + ?Sized, S: Spans>(visitor: &mut V, spans: &mut S) {
+ spans.visit_mut(visitor);
+ }
+
+ pub trait Spans {
+ fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V);
+ }
+
+ impl Spans for Span {
+ fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
+ visitor.visit_span_mut(self);
+ }
+ }
+
+ impl Spans for [Span; 1] {
+ fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
+ visitor.visit_span_mut(&mut self[0]);
+ }
+ }
+
+ impl Spans for [Span; 2] {
+ fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
+ visitor.visit_span_mut(&mut self[0]);
+ visitor.visit_span_mut(&mut self[1]);
+ }
+ }
+
+ impl Spans for [Span; 3] {
+ fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) {
+ visitor.visit_span_mut(&mut self[0]);
+ visitor.visit_span_mut(&mut self[1]);
+ visitor.visit_span_mut(&mut self[2]);
+ }
+ }
+}
copy from third_party/rust/syn/src/generics.rs
copy to third_party/rust/syn-0.12.12/src/generics.rs
copy from third_party/rust/syn/src/ident.rs
copy to third_party/rust/syn-0.12.12/src/ident.rs
copy from third_party/rust/syn/src/item.rs
copy to third_party/rust/syn-0.12.12/src/item.rs
copy from third_party/rust/syn/src/lib.rs
copy to third_party/rust/syn-0.12.12/src/lib.rs
copy from third_party/rust/syn/src/lifetime.rs
copy to third_party/rust/syn-0.12.12/src/lifetime.rs
copy from third_party/rust/syn/src/lit.rs
copy to third_party/rust/syn-0.12.12/src/lit.rs
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/mac.rs
@@ -0,0 +1,115 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+use proc_macro2::TokenStream;
+use token::{Brace, Bracket, Paren};
+
+#[cfg(feature = "extra-traits")]
+use std::hash::{Hash, Hasher};
+#[cfg(feature = "extra-traits")]
+use tt::TokenStreamHelper;
+
+ast_struct! {
+ /// A macro invocation: `println!("{}", mac)`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct Macro #manual_extra_traits {
+ pub path: Path,
+ pub bang_token: Token![!],
+ pub delimiter: MacroDelimiter,
+ pub tts: TokenStream,
+ }
+}
+
+ast_enum! {
+ /// A grouping token that surrounds a macro body: `m!(...)` or `m!{...}` or `m![...]`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub enum MacroDelimiter {
+ Paren(Paren),
+ Brace(Brace),
+ Bracket(Bracket),
+ }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Eq for Macro {}
+
+#[cfg(feature = "extra-traits")]
+impl PartialEq for Macro {
+ fn eq(&self, other: &Self) -> bool {
+ self.path == other.path && self.bang_token == other.bang_token
+ && self.delimiter == other.delimiter
+ && TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
+ }
+}
+
+#[cfg(feature = "extra-traits")]
+impl Hash for Macro {
+ fn hash<H>(&self, state: &mut H)
+ where
+ H: Hasher,
+ {
+ self.path.hash(state);
+ self.bang_token.hash(state);
+ self.delimiter.hash(state);
+ TokenStreamHelper(&self.tts).hash(state);
+ }
+}
+
+#[cfg(feature = "parsing")]
+pub mod parsing {
+ use super::*;
+
+ use synom::Synom;
+
+ impl Synom for Macro {
+ named!(parse -> Self, do_parse!(
+ what: call!(Path::parse_mod_style) >>
+ bang: punct!(!) >>
+ body: call!(tt::delimited) >>
+ (Macro {
+ path: what,
+ bang_token: bang,
+ delimiter: body.0,
+ tts: body.1,
+ })
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("macro invocation")
+ }
+ }
+}
+
+#[cfg(feature = "printing")]
+mod printing {
+ use super::*;
+ use quote::{ToTokens, Tokens};
+
+ impl ToTokens for Macro {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.path.to_tokens(tokens);
+ self.bang_token.to_tokens(tokens);
+ match self.delimiter {
+ MacroDelimiter::Paren(ref paren) => {
+ paren.surround(tokens, |tokens| self.tts.to_tokens(tokens));
+ }
+ MacroDelimiter::Brace(ref brace) => {
+ brace.surround(tokens, |tokens| self.tts.to_tokens(tokens));
+ }
+ MacroDelimiter::Bracket(ref bracket) => {
+ bracket.surround(tokens, |tokens| self.tts.to_tokens(tokens));
+ }
+ }
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/macros.rs
@@ -0,0 +1,186 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(any(feature = "full", feature = "derive"))]
+macro_rules! ast_struct {
+ (
+ $(#[$attr:meta])*
+ pub struct $name:ident #full $($rest:tt)*
+ ) => {
+ #[cfg(feature = "full")]
+ $(#[$attr])*
+ #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
+ #[cfg_attr(feature = "clone-impls", derive(Clone))]
+ pub struct $name $($rest)*
+
+ #[cfg(not(feature = "full"))]
+ $(#[$attr])*
+ #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
+ #[cfg_attr(feature = "clone-impls", derive(Clone))]
+ pub struct $name {
+ _noconstruct: (),
+ }
+ };
+
+ (
+ $(#[$attr:meta])*
+ pub struct $name:ident #manual_extra_traits $($rest:tt)*
+ ) => {
+ $(#[$attr])*
+ #[cfg_attr(feature = "extra-traits", derive(Debug))]
+ #[cfg_attr(feature = "clone-impls", derive(Clone))]
+ pub struct $name $($rest)*
+ };
+
+ (
+ $(#[$attr:meta])*
+ pub struct $name:ident $($rest:tt)*
+ ) => {
+ $(#[$attr])*
+ #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
+ #[cfg_attr(feature = "clone-impls", derive(Clone))]
+ pub struct $name $($rest)*
+ };
+}
+
+#[cfg(any(feature = "full", feature = "derive"))]
+macro_rules! ast_enum {
+ (
+ $(#[$enum_attr:meta])*
+ pub enum $name:ident $(# $tags:ident)* { $($variants:tt)* }
+ ) => (
+ $(#[$enum_attr])*
+ #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
+ #[cfg_attr(feature = "clone-impls", derive(Clone))]
+ pub enum $name {
+ $($variants)*
+ }
+ )
+}
+
+#[cfg(any(feature = "full", feature = "derive"))]
+macro_rules! ast_enum_of_structs {
+ (
+ $(#[$enum_attr:meta])*
+ pub enum $name:ident {
+ $(
+ $(#[$variant_attr:meta])*
+ pub $variant:ident $( ($member:ident $($rest:tt)*) )*,
+ )*
+ }
+
+ $($remaining:tt)*
+ ) => (
+ ast_enum! {
+ $(#[$enum_attr])*
+ pub enum $name {
+ $(
+ $(#[$variant_attr])*
+ $variant $( ($member) )*,
+ )*
+ }
+ }
+
+ $(
+ maybe_ast_struct! {
+ $(#[$variant_attr])*
+ $(
+ pub struct $member $($rest)*
+ )*
+ }
+
+ $(
+ impl From<$member> for $name {
+ fn from(e: $member) -> $name {
+ $name::$variant(e)
+ }
+ }
+ )*
+ )*
+
+ #[cfg(feature = "printing")]
+ generate_to_tokens! {
+ $($remaining)*
+ ()
+ tokens
+ $name { $($variant $( [$($rest)*] )*,)* }
+ }
+ )
+}
+
+#[cfg(all(feature = "printing", any(feature = "full", feature = "derive")))]
+macro_rules! generate_to_tokens {
+ (do_not_generate_to_tokens $($foo:tt)*) => ();
+
+ (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident, $($next:tt)*}) => {
+ generate_to_tokens!(
+ ($($arms)* $name::$variant => {})
+ $tokens $name { $($next)* }
+ );
+ };
+
+ (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident [$($rest:tt)*], $($next:tt)*}) => {
+ generate_to_tokens!(
+ ($($arms)* $name::$variant(ref _e) => to_tokens_call!(_e, $tokens, $($rest)*),)
+ $tokens $name { $($next)* }
+ );
+ };
+
+ (($($arms:tt)*) $tokens:ident $name:ident {}) => {
+ impl ::quote::ToTokens for $name {
+ fn to_tokens(&self, $tokens: &mut ::quote::Tokens) {
+ match *self {
+ $($arms)*
+ }
+ }
+ }
+ };
+}
+
+#[cfg(all(feature = "printing", feature = "full"))]
+macro_rules! to_tokens_call {
+ ($e:ident, $tokens:ident, $($rest:tt)*) => {
+ $e.to_tokens($tokens)
+ };
+}
+
+#[cfg(all(feature = "printing", feature = "derive", not(feature = "full")))]
+macro_rules! to_tokens_call {
+ // If the variant is marked as #full, don't auto-generate to-tokens for it.
+ ($e:ident, $tokens:ident, #full $($rest:tt)*) => {
+ unreachable!()
+ };
+ ($e:ident, $tokens:ident, $($rest:tt)*) => {
+ $e.to_tokens($tokens)
+ };
+}
+
+#[cfg(any(feature = "full", feature = "derive"))]
+macro_rules! maybe_ast_struct {
+ (
+ $(#[$attr:meta])*
+ $(
+ pub struct $name:ident
+ )*
+ ) => ();
+
+ ($($rest:tt)*) => (ast_struct! { $($rest)* });
+}
+
+#[cfg(all(feature = "parsing", any(feature = "full", feature = "derive")))]
+macro_rules! impl_synom {
+ ($t:ident $description:tt $($parser:tt)+) => {
+ impl Synom for $t {
+ named!(parse -> Self, $($parser)+);
+
+ fn description() -> Option<&'static str> {
+ Some($description)
+ }
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/op.rs
@@ -0,0 +1,223 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+ast_enum! {
+ /// A binary operator: `+`, `+=`, `&`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ #[cfg_attr(feature = "clone-impls", derive(Copy))]
+ pub enum BinOp {
+ /// The `+` operator (addition)
+ Add(Token![+]),
+ /// The `-` operator (subtraction)
+ Sub(Token![-]),
+ /// The `*` operator (multiplication)
+ Mul(Token![*]),
+ /// The `/` operator (division)
+ Div(Token![/]),
+ /// The `%` operator (modulus)
+ Rem(Token![%]),
+ /// The `&&` operator (logical and)
+ And(Token![&&]),
+ /// The `||` operator (logical or)
+ Or(Token![||]),
+ /// The `^` operator (bitwise xor)
+ BitXor(Token![^]),
+ /// The `&` operator (bitwise and)
+ BitAnd(Token![&]),
+ /// The `|` operator (bitwise or)
+ BitOr(Token![|]),
+ /// The `<<` operator (shift left)
+ Shl(Token![<<]),
+ /// The `>>` operator (shift right)
+ Shr(Token![>>]),
+ /// The `==` operator (equality)
+ Eq(Token![==]),
+ /// The `<` operator (less than)
+ Lt(Token![<]),
+ /// The `<=` operator (less than or equal to)
+ Le(Token![<=]),
+ /// The `!=` operator (not equal to)
+ Ne(Token![!=]),
+ /// The `>=` operator (greater than or equal to)
+ Ge(Token![>=]),
+ /// The `>` operator (greater than)
+ Gt(Token![>]),
+ /// The `+=` operator
+ AddEq(Token![+=]),
+ /// The `-=` operator
+ SubEq(Token![-=]),
+ /// The `*=` operator
+ MulEq(Token![*=]),
+ /// The `/=` operator
+ DivEq(Token![/=]),
+ /// The `%=` operator
+ RemEq(Token![%=]),
+ /// The `^=` operator
+ BitXorEq(Token![^=]),
+ /// The `&=` operator
+ BitAndEq(Token![&=]),
+ /// The `|=` operator
+ BitOrEq(Token![|=]),
+ /// The `<<=` operator
+ ShlEq(Token![<<=]),
+ /// The `>>=` operator
+ ShrEq(Token![>>=]),
+ }
+}
+
+ast_enum! {
+ /// A unary operator: `*`, `!`, `-`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ #[cfg_attr(feature = "clone-impls", derive(Copy))]
+ pub enum UnOp {
+ /// The `*` operator for dereferencing
+ Deref(Token![*]),
+ /// The `!` operator for logical inversion
+ Not(Token![!]),
+ /// The `-` operator for negation
+ Neg(Token![-]),
+ }
+}
+
+#[cfg(feature = "parsing")]
+pub mod parsing {
+ use super::*;
+ use synom::Synom;
+
+ impl BinOp {
+ named!(pub parse_binop -> Self, alt!(
+ punct!(&&) => { BinOp::And }
+ |
+ punct!(||) => { BinOp::Or }
+ |
+ punct!(<<) => { BinOp::Shl }
+ |
+ punct!(>>) => { BinOp::Shr }
+ |
+ punct!(==) => { BinOp::Eq }
+ |
+ punct!(<=) => { BinOp::Le }
+ |
+ punct!(!=) => { BinOp::Ne }
+ |
+ punct!(>=) => { BinOp::Ge }
+ |
+ punct!(+) => { BinOp::Add }
+ |
+ punct!(-) => { BinOp::Sub }
+ |
+ punct!(*) => { BinOp::Mul }
+ |
+ punct!(/) => { BinOp::Div }
+ |
+ punct!(%) => { BinOp::Rem }
+ |
+ punct!(^) => { BinOp::BitXor }
+ |
+ punct!(&) => { BinOp::BitAnd }
+ |
+ punct!(|) => { BinOp::BitOr }
+ |
+ punct!(<) => { BinOp::Lt }
+ |
+ punct!(>) => { BinOp::Gt }
+ ));
+
+ #[cfg(feature = "full")]
+ named!(pub parse_assign_op -> Self, alt!(
+ punct!(+=) => { BinOp::AddEq }
+ |
+ punct!(-=) => { BinOp::SubEq }
+ |
+ punct!(*=) => { BinOp::MulEq }
+ |
+ punct!(/=) => { BinOp::DivEq }
+ |
+ punct!(%=) => { BinOp::RemEq }
+ |
+ punct!(^=) => { BinOp::BitXorEq }
+ |
+ punct!(&=) => { BinOp::BitAndEq }
+ |
+ punct!(|=) => { BinOp::BitOrEq }
+ |
+ punct!(<<=) => { BinOp::ShlEq }
+ |
+ punct!(>>=) => { BinOp::ShrEq }
+ ));
+ }
+
+ impl Synom for UnOp {
+ named!(parse -> Self, alt!(
+ punct!(*) => { UnOp::Deref }
+ |
+ punct!(!) => { UnOp::Not }
+ |
+ punct!(-) => { UnOp::Neg }
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("unary operator: `*`, `!`, or `-`")
+ }
+ }
+}
+
+#[cfg(feature = "printing")]
+mod printing {
+ use super::*;
+ use quote::{ToTokens, Tokens};
+
+ impl ToTokens for BinOp {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ match *self {
+ BinOp::Add(ref t) => t.to_tokens(tokens),
+ BinOp::Sub(ref t) => t.to_tokens(tokens),
+ BinOp::Mul(ref t) => t.to_tokens(tokens),
+ BinOp::Div(ref t) => t.to_tokens(tokens),
+ BinOp::Rem(ref t) => t.to_tokens(tokens),
+ BinOp::And(ref t) => t.to_tokens(tokens),
+ BinOp::Or(ref t) => t.to_tokens(tokens),
+ BinOp::BitXor(ref t) => t.to_tokens(tokens),
+ BinOp::BitAnd(ref t) => t.to_tokens(tokens),
+ BinOp::BitOr(ref t) => t.to_tokens(tokens),
+ BinOp::Shl(ref t) => t.to_tokens(tokens),
+ BinOp::Shr(ref t) => t.to_tokens(tokens),
+ BinOp::Eq(ref t) => t.to_tokens(tokens),
+ BinOp::Lt(ref t) => t.to_tokens(tokens),
+ BinOp::Le(ref t) => t.to_tokens(tokens),
+ BinOp::Ne(ref t) => t.to_tokens(tokens),
+ BinOp::Ge(ref t) => t.to_tokens(tokens),
+ BinOp::Gt(ref t) => t.to_tokens(tokens),
+ BinOp::AddEq(ref t) => t.to_tokens(tokens),
+ BinOp::SubEq(ref t) => t.to_tokens(tokens),
+ BinOp::MulEq(ref t) => t.to_tokens(tokens),
+ BinOp::DivEq(ref t) => t.to_tokens(tokens),
+ BinOp::RemEq(ref t) => t.to_tokens(tokens),
+ BinOp::BitXorEq(ref t) => t.to_tokens(tokens),
+ BinOp::BitAndEq(ref t) => t.to_tokens(tokens),
+ BinOp::BitOrEq(ref t) => t.to_tokens(tokens),
+ BinOp::ShlEq(ref t) => t.to_tokens(tokens),
+ BinOp::ShrEq(ref t) => t.to_tokens(tokens),
+ }
+ }
+ }
+
+ impl ToTokens for UnOp {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ match *self {
+ UnOp::Deref(ref t) => t.to_tokens(tokens),
+ UnOp::Not(ref t) => t.to_tokens(tokens),
+ UnOp::Neg(ref t) => t.to_tokens(tokens),
+ }
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/parse_quote.rs
@@ -0,0 +1,160 @@
+/// Quasi-quotation macro that accepts input like the [`quote!`] macro but uses
+/// type inference to figure out a return type for those tokens.
+///
+/// [`quote!`]: https://docs.rs/quote/0.4/quote/index.html
+///
+/// The return type can be any syntax tree node that implements the [`Synom`]
+/// trait.
+///
+/// [`Synom`]: synom/trait.Synom.html
+///
+/// ```
+/// #[macro_use]
+/// extern crate syn;
+///
+/// #[macro_use]
+/// extern crate quote;
+///
+/// use syn::Stmt;
+///
+/// fn main() {
+/// let name = quote!(v);
+/// let ty = quote!(u8);
+///
+/// let stmt: Stmt = parse_quote! {
+/// let #name: #ty = Default::default();
+/// };
+///
+/// println!("{:#?}", stmt);
+/// }
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature,
+/// although interpolation of syntax tree nodes into the quoted tokens is only
+/// supported if Syn is built with the `"printing"` feature as well.*
+///
+/// # Example
+///
+/// The following helper function adds a bound `T: HeapSize` to every type
+/// parameter `T` in the input generics.
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate syn;
+/// #
+/// # #[macro_use]
+/// # extern crate quote;
+/// #
+/// # use syn::{Generics, GenericParam};
+/// #
+/// // Add a bound `T: HeapSize` to every type parameter T.
+/// fn add_trait_bounds(mut generics: Generics) -> Generics {
+/// for param in &mut generics.params {
+/// if let GenericParam::Type(ref mut type_param) = *param {
+/// type_param.bounds.push(parse_quote!(HeapSize));
+/// }
+/// }
+/// generics
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// # Special cases
+///
+/// This macro can parse the following additional types as a special case even
+/// though they do not implement the `Synom` trait.
+///
+/// - [`Attribute`] — parses one attribute, allowing either outer like `#[...]`
+/// or inner like `#![...]`
+/// - [`Punctuated<T, P>`] — parses zero or more `T` separated by punctuation
+/// `P` with optional trailing punctuation
+///
+/// [`Attribute`]: struct.Attribute.html
+/// [`Punctuated<T, P>`]: punctuated/struct.Punctuated.html
+///
+/// # Panics
+///
+/// Panics if the tokens fail to parse as the expected syntax tree type. The
+/// caller is responsible for ensuring that the input tokens are syntactically
+/// valid.
+#[macro_export]
+macro_rules! parse_quote {
+ ($($tt:tt)*) => {
+ $crate::parse_quote::parse($crate::parse_quote::From::from(quote!($($tt)*)))
+ };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Can parse any type that implements Synom.
+
+use synom::{Synom, Parser, PResult};
+use buffer::Cursor;
+use proc_macro2::TokenStream;
+
+// Not public API.
+#[doc(hidden)]
+pub use std::convert::From;
+
+// Not public API.
+#[doc(hidden)]
+pub fn parse<T: ParseQuote>(token_stream: TokenStream) -> T {
+ let parser = T::parse;
+ match parser.parse2(token_stream) {
+ Ok(t) => t,
+ Err(err) => match T::description() {
+ Some(s) => panic!("failed to parse {}: {}", s, err),
+ None => panic!("{}", err),
+ }
+ }
+}
+
+// Not public API.
+#[doc(hidden)]
+pub trait ParseQuote: Sized {
+ fn parse(input: Cursor) -> PResult<Self>;
+ fn description() -> Option<&'static str>;
+}
+
+impl<T> ParseQuote for T where T: Synom {
+ fn parse(input: Cursor) -> PResult<Self> {
+ <T as Synom>::parse(input)
+ }
+
+ fn description() -> Option<&'static str> {
+ <T as Synom>::description()
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Any other types that we want `parse_quote!` to be able to parse.
+
+use punctuated::Punctuated;
+
+#[cfg(any(feature = "full", feature = "derive"))]
+use Attribute;
+
+impl<T, P> ParseQuote for Punctuated<T, P>
+where
+ T: Synom,
+ P: Synom,
+{
+ named!(parse -> Self, call!(Punctuated::parse_terminated));
+
+ fn description() -> Option<&'static str> {
+ Some("punctuated sequence")
+ }
+}
+
+#[cfg(any(feature = "full", feature = "derive"))]
+impl ParseQuote for Attribute {
+ named!(parse -> Self, alt!(
+ call!(Attribute::parse_outer)
+ |
+ call!(Attribute::parse_inner)
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("attribute")
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/parsers.rs
@@ -0,0 +1,1384 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use buffer::Cursor;
+use parse_error;
+use synom::PResult;
+
+/// Define a parser function with the signature expected by syn parser
+/// combinators.
+///
+/// The function may be the `parse` function of the [`Synom`] trait, or it may
+/// be a free-standing function with an arbitrary name. When implementing the
+/// `Synom` trait, the function name is `parse` and the return type is `Self`.
+///
+/// [`Synom`]: synom/trait.Synom.html
+///
+/// - **Syntax:** `named!(NAME -> TYPE, PARSER)` or `named!(pub NAME -> TYPE, PARSER)`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Type;
+/// use syn::punctuated::Punctuated;
+/// use syn::synom::Synom;
+///
+/// /// Parses one or more Rust types separated by commas.
+/// ///
+/// /// Example: `String, Vec<T>, [u8; LEN + 1]`
+/// named!(pub comma_separated_types -> Punctuated<Type, Token![,]>,
+/// call!(Punctuated::parse_separated_nonempty)
+/// );
+///
+/// /// The same function as a `Synom` implementation.
+/// struct CommaSeparatedTypes {
+/// types: Punctuated<Type, Token![,]>,
+/// }
+///
+/// impl Synom for CommaSeparatedTypes {
+/// /// As the default behavior, we want there to be at least 1 type.
+/// named!(parse -> Self, do_parse!(
+/// types: call!(Punctuated::parse_separated_nonempty) >>
+/// (CommaSeparatedTypes { types })
+/// ));
+/// }
+///
+/// impl CommaSeparatedTypes {
+/// /// A separate parser that the user can invoke explicitly which allows
+/// /// for parsing 0 or more types, rather than the default 1 or more.
+/// named!(pub parse0 -> Self, do_parse!(
+/// types: call!(Punctuated::parse_separated) >>
+/// (CommaSeparatedTypes { types })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! named {
+ ($name:ident -> $o:ty, $submac:ident!( $($args:tt)* )) => {
+ fn $name(i: $crate::buffer::Cursor) -> $crate::synom::PResult<$o> {
+ $submac!(i, $($args)*)
+ }
+ };
+
+ (pub $name:ident -> $o:ty, $submac:ident!( $($args:tt)* )) => {
+ pub fn $name(i: $crate::buffer::Cursor) -> $crate::synom::PResult<$o> {
+ $submac!(i, $($args)*)
+ }
+ };
+
+ // These two variants are for defining named parsers which have custom
+ // arguments, and are called with `call!()`
+ ($name:ident($($params:tt)*) -> $o:ty, $submac:ident!( $($args:tt)* )) => {
+ fn $name(i: $crate::buffer::Cursor, $($params)*) -> $crate::synom::PResult<$o> {
+ $submac!(i, $($args)*)
+ }
+ };
+
+ (pub $name:ident($($params:tt)*) -> $o:ty, $submac:ident!( $($args:tt)* )) => {
+ pub fn $name(i: $crate::buffer::Cursor, $($params)*) -> $crate::synom::PResult<$o> {
+ $submac!(i, $($args)*)
+ }
+ };
+}
+
+#[cfg(synom_verbose_trace)]
+#[macro_export]
+macro_rules! call {
+ ($i:expr, $fun:expr $(, $args:expr)*) => {{
+ let i = $i;
+ eprintln!(concat!(" -> ", stringify!($fun), " @ {:?}"), i);
+ let r = $fun(i $(, $args)*);
+ match r {
+ Ok((_, i)) => eprintln!(concat!("OK ", stringify!($fun), " @ {:?}"), i),
+ Err(_) => eprintln!(concat!("ERR ", stringify!($fun), " @ {:?}"), i),
+ }
+ r
+ }};
+}
+
+/// Invoke the given parser function with zero or more arguments.
+///
+/// - **Syntax:** `call!(FN, ARGS...)`
+///
+/// where the signature of the function is `fn(Cursor, ARGS...) -> PResult<T>`
+///
+/// - **Output:** `T`, the result of invoking the function `FN`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Type;
+/// use syn::punctuated::Punctuated;
+/// use syn::synom::Synom;
+///
+/// /// Parses one or more Rust types separated by commas.
+/// ///
+/// /// Example: `String, Vec<T>, [u8; LEN + 1]`
+/// struct CommaSeparatedTypes {
+/// types: Punctuated<Type, Token![,]>,
+/// }
+///
+/// impl Synom for CommaSeparatedTypes {
+/// named!(parse -> Self, do_parse!(
+/// types: call!(Punctuated::parse_separated_nonempty) >>
+/// (CommaSeparatedTypes { types })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[cfg(not(synom_verbose_trace))]
+#[macro_export]
+macro_rules! call {
+ ($i:expr, $fun:expr $(, $args:expr)*) => {
+ $fun($i $(, $args)*)
+ };
+}
+
+/// Transform the result of a parser by applying a function or closure.
+///
+/// - **Syntax:** `map!(THING, FN)`
+/// - **Output:** the return type of function FN applied to THING
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::{Expr, ExprIf};
+///
+/// /// Extracts the branch condition of an `if`-expression.
+/// fn get_cond(if_: ExprIf) -> Expr {
+/// *if_.cond
+/// }
+///
+/// /// Parses a full `if`-expression but returns the condition part only.
+/// ///
+/// /// Example: `if x > 0xFF { "big" } else { "small" }`
+/// /// The return would be the expression `x > 0xFF`.
+/// named!(if_condition -> Expr,
+/// map!(syn!(ExprIf), get_cond)
+/// );
+///
+/// /// Equivalent using a closure.
+/// named!(if_condition2 -> Expr,
+/// map!(syn!(ExprIf), |if_| *if_.cond)
+/// );
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! map {
+ ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) =>
+ ::std::result::Result::Ok(($crate::parsers::invoke($g, o), i)),
+ }
+ };
+
+ ($i:expr, $f:expr, $g:expr) => {
+ map!($i, call!($f), $g)
+ };
+}
+
+// Somehow this helps with type inference in `map!` and `alt!`.
+//
+// Not public API.
+#[doc(hidden)]
+pub fn invoke<T, R, F: FnOnce(T) -> R>(f: F, t: T) -> R {
+ f(t)
+}
+
+/// Invert the result of a parser by parsing successfully if the given parser
+/// fails to parse and vice versa.
+///
+/// Does not consume any of the input.
+///
+/// - **Syntax:** `not!(THING)`
+/// - **Output:** `()`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::{Expr, Ident};
+///
+/// /// Parses any expression that does not begin with a `-` minus sign.
+/// named!(not_negative_expr -> Expr, do_parse!(
+/// not!(punct!(-)) >>
+/// e: syn!(Expr) >>
+/// (e)
+/// ));
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! not {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Ok(_) => $crate::parse_error(),
+ ::std::result::Result::Err(_) =>
+ ::std::result::Result::Ok(((), $i)),
+ }
+ };
+}
+
+/// Execute a parser only if a condition is met, otherwise return None.
+///
+/// If you are familiar with nom, this is nom's `cond_with_error` parser.
+///
+/// - **Syntax:** `cond!(CONDITION, THING)`
+/// - **Output:** `Some(THING)` if the condition is true, else `None`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::{Ident, MacroDelimiter};
+/// use syn::token::{Paren, Bracket, Brace};
+/// use syn::synom::Synom;
+///
+/// /// Parses a macro call with empty input. If the macro is written with
+/// /// parentheses or brackets, a trailing semicolon is required.
+/// ///
+/// /// Example: `my_macro!{}` or `my_macro!();` or `my_macro![];`
+/// struct EmptyMacroCall {
+/// name: Ident,
+/// bang_token: Token![!],
+/// empty_body: MacroDelimiter,
+/// semi_token: Option<Token![;]>,
+/// }
+///
+/// fn requires_semi(delimiter: &MacroDelimiter) -> bool {
+/// match *delimiter {
+/// MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => true,
+/// MacroDelimiter::Brace(_) => false,
+/// }
+/// }
+///
+/// impl Synom for EmptyMacroCall {
+/// named!(parse -> Self, do_parse!(
+/// name: syn!(Ident) >>
+/// bang_token: punct!(!) >>
+/// empty_body: alt!(
+/// parens!(epsilon!()) => { |d| MacroDelimiter::Paren(d.0) }
+/// |
+/// brackets!(epsilon!()) => { |d| MacroDelimiter::Bracket(d.0) }
+/// |
+/// braces!(epsilon!()) => { |d| MacroDelimiter::Brace(d.0) }
+/// ) >>
+/// semi_token: cond!(requires_semi(&empty_body), punct!(;)) >>
+/// (EmptyMacroCall {
+/// name,
+/// bang_token,
+/// empty_body,
+/// semi_token,
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! cond {
+ ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => {
+ if $cond {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Ok((o, i)) =>
+ ::std::result::Result::Ok((::std::option::Option::Some(o), i)),
+ ::std::result::Result::Err(x) => ::std::result::Result::Err(x),
+ }
+ } else {
+ ::std::result::Result::Ok((::std::option::Option::None, $i))
+ }
+ };
+
+ ($i:expr, $cond:expr, $f:expr) => {
+ cond!($i, $cond, call!($f))
+ };
+}
+
+/// Execute a parser only if a condition is met, otherwise fail to parse.
+///
+/// This is typically used inside of [`option!`] or [`alt!`].
+///
+/// [`option!`]: macro.option.html
+/// [`alt!`]: macro.alt.html
+///
+/// - **Syntax:** `cond_reduce!(CONDITION, THING)`
+/// - **Output:** `THING`
+///
+/// The subparser may be omitted in which case it defaults to [`epsilon!`].
+///
+/// [`epsilon!`]: macro.epsilon.html
+///
+/// - **Syntax:** `cond_reduce!(CONDITION)`
+/// - **Output:** `()`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Type;
+/// use syn::token::Paren;
+/// use syn::punctuated::Punctuated;
+/// use syn::synom::Synom;
+///
+/// /// Parses a possibly variadic function signature.
+/// ///
+/// /// Example: `fn(A) or `fn(A, B, C, ...)` or `fn(...)`
+/// /// Rejected: `fn(A, B...)`
+/// struct VariadicFn {
+/// fn_token: Token![fn],
+/// paren_token: Paren,
+/// types: Punctuated<Type, Token![,]>,
+/// variadic: Option<Token![...]>,
+/// }
+///
+/// // Example of using `cond_reduce!` inside of `option!`.
+/// impl Synom for VariadicFn {
+/// named!(parse -> Self, do_parse!(
+/// fn_token: keyword!(fn) >>
+/// params: parens!(do_parse!(
+/// types: call!(Punctuated::parse_terminated) >>
+/// // Allow, but do not require, an ending `...` but only if the
+/// // preceding list of types is empty or ends with a trailing comma.
+/// variadic: option!(cond_reduce!(types.empty_or_trailing(), punct!(...))) >>
+/// (types, variadic)
+/// )) >>
+/// ({
+/// let (paren_token, (types, variadic)) = params;
+/// VariadicFn {
+/// fn_token,
+/// paren_token,
+/// types,
+/// variadic,
+/// }
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! cond_reduce {
+ ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => {
+ if $cond {
+ $submac!($i, $($args)*)
+ } else {
+ $crate::parse_error()
+ }
+ };
+
+ ($i:expr, $cond:expr) => {
+ cond_reduce!($i, $cond, epsilon!())
+ };
+
+ ($i:expr, $cond:expr, $f:expr) => {
+ cond_reduce!($i, $cond, call!($f))
+ };
+}
+
+/// Parse zero or more values using the given parser.
+///
+/// - **Syntax:** `many0!(THING)`
+/// - **Output:** `Vec<THING>`
+///
+/// You may also be looking for:
+///
+/// - `call!(Punctuated::parse_separated)` - zero or more values with separator
+/// - `call!(Punctuated::parse_separated_nonempty)` - one or more values
+/// - `call!(Punctuated::parse_terminated)` - zero or more, allows trailing separator
+/// - `call!(Punctuated::parse_terminated_nonempty)` - one or more
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::{Ident, Item};
+/// use syn::token::Brace;
+/// use syn::synom::Synom;
+///
+/// /// Parses a module containing zero or more Rust items.
+/// ///
+/// /// Example: `mod m { type Result<T> = ::std::result::Result<T, MyError>; }`
+/// struct SimpleMod {
+/// mod_token: Token![mod],
+/// name: Ident,
+/// brace_token: Brace,
+/// items: Vec<Item>,
+/// }
+///
+/// impl Synom for SimpleMod {
+/// named!(parse -> Self, do_parse!(
+/// mod_token: keyword!(mod) >>
+/// name: syn!(Ident) >>
+/// body: braces!(many0!(syn!(Item))) >>
+/// (SimpleMod {
+/// mod_token,
+/// name,
+/// brace_token: body.0,
+/// items: body.1,
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! many0 {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {{
+ let ret;
+ let mut res = ::std::vec::Vec::new();
+ let mut input = $i;
+
+ loop {
+ if input.eof() {
+ ret = ::std::result::Result::Ok((res, input));
+ break;
+ }
+
+ match $submac!(input, $($args)*) {
+ ::std::result::Result::Err(_) => {
+ ret = ::std::result::Result::Ok((res, input));
+ break;
+ }
+ ::std::result::Result::Ok((o, i)) => {
+ // loop trip must always consume (otherwise infinite loops)
+ if i == input {
+ ret = $crate::parse_error();
+ break;
+ }
+
+ res.push(o);
+ input = i;
+ }
+ }
+ }
+
+ ret
+ }};
+
+ ($i:expr, $f:expr) => {
+ $crate::parsers::many0($i, $f)
+ };
+}
+
+// Improve compile time by compiling this loop only once per type it is used
+// with.
+//
+// Not public API.
+#[doc(hidden)]
+pub fn many0<T>(mut input: Cursor, f: fn(Cursor) -> PResult<T>) -> PResult<Vec<T>> {
+ let mut res = Vec::new();
+
+ loop {
+ if input.eof() {
+ return Ok((res, input));
+ }
+
+ match f(input) {
+ Err(_) => {
+ return Ok((res, input));
+ }
+ Ok((o, i)) => {
+ // loop trip must always consume (otherwise infinite loops)
+ if i == input {
+ return parse_error();
+ }
+
+ res.push(o);
+ input = i;
+ }
+ }
+ }
+}
+
+/// Pattern-match the result of a parser to select which other parser to run.
+///
+/// - **Syntax:** `switch!(TARGET, PAT1 => THEN1 | PAT2 => THEN2 | ...)`
+/// - **Output:** `T`, the return type of `THEN1` and `THEN2` and ...
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Ident;
+/// use syn::token::Brace;
+/// use syn::synom::Synom;
+///
+/// /// Parse a unit struct or enum: either `struct S;` or `enum E { V }`.
+/// enum UnitType {
+/// Struct {
+/// struct_token: Token![struct],
+/// name: Ident,
+/// semi_token: Token![;],
+/// },
+/// Enum {
+/// enum_token: Token![enum],
+/// name: Ident,
+/// brace_token: Brace,
+/// variant: Ident,
+/// },
+/// }
+///
+/// enum StructOrEnum {
+/// Struct(Token![struct]),
+/// Enum(Token![enum]),
+/// }
+///
+/// impl Synom for StructOrEnum {
+/// named!(parse -> Self, alt!(
+/// keyword!(struct) => { StructOrEnum::Struct }
+/// |
+/// keyword!(enum) => { StructOrEnum::Enum }
+/// ));
+/// }
+///
+/// impl Synom for UnitType {
+/// named!(parse -> Self, do_parse!(
+/// which: syn!(StructOrEnum) >>
+/// name: syn!(Ident) >>
+/// item: switch!(value!(which),
+/// StructOrEnum::Struct(struct_token) => map!(
+/// punct!(;),
+/// |semi_token| UnitType::Struct {
+/// struct_token,
+/// name,
+/// semi_token,
+/// }
+/// )
+/// |
+/// StructOrEnum::Enum(enum_token) => map!(
+/// braces!(syn!(Ident)),
+/// |(brace_token, variant)| UnitType::Enum {
+/// enum_token,
+/// name,
+/// brace_token,
+/// variant,
+/// }
+/// )
+/// ) >>
+/// (item)
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! switch {
+ ($i:expr, $submac:ident!( $($args:tt)* ), $($p:pat => $subrule:ident!( $($args2:tt)* ))|* ) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) => ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) => match o {
+ $(
+ $p => $subrule!(i, $($args2)*),
+ )*
+ }
+ }
+ };
+}
+
+/// Produce the given value without parsing anything.
+///
+/// This can be needed where you have an existing parsed value but a parser
+/// macro's syntax expects you to provide a submacro, such as in the first
+/// argument of [`switch!`] or one of the branches of [`alt!`].
+///
+/// [`switch!`]: macro.switch.html
+/// [`alt!`]: macro.alt.html
+///
+/// - **Syntax:** `value!(VALUE)`
+/// - **Output:** `VALUE`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Ident;
+/// use syn::token::Brace;
+/// use syn::synom::Synom;
+///
+/// /// Parse a unit struct or enum: either `struct S;` or `enum E { V }`.
+/// enum UnitType {
+/// Struct {
+/// struct_token: Token![struct],
+/// name: Ident,
+/// semi_token: Token![;],
+/// },
+/// Enum {
+/// enum_token: Token![enum],
+/// name: Ident,
+/// brace_token: Brace,
+/// variant: Ident,
+/// },
+/// }
+///
+/// enum StructOrEnum {
+/// Struct(Token![struct]),
+/// Enum(Token![enum]),
+/// }
+///
+/// impl Synom for StructOrEnum {
+/// named!(parse -> Self, alt!(
+/// keyword!(struct) => { StructOrEnum::Struct }
+/// |
+/// keyword!(enum) => { StructOrEnum::Enum }
+/// ));
+/// }
+///
+/// impl Synom for UnitType {
+/// named!(parse -> Self, do_parse!(
+/// which: syn!(StructOrEnum) >>
+/// name: syn!(Ident) >>
+/// item: switch!(value!(which),
+/// StructOrEnum::Struct(struct_token) => map!(
+/// punct!(;),
+/// |semi_token| UnitType::Struct {
+/// struct_token,
+/// name,
+/// semi_token,
+/// }
+/// )
+/// |
+/// StructOrEnum::Enum(enum_token) => map!(
+/// braces!(syn!(Ident)),
+/// |(brace_token, variant)| UnitType::Enum {
+/// enum_token,
+/// name,
+/// brace_token,
+/// variant,
+/// }
+/// )
+/// ) >>
+/// (item)
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! value {
+ ($i:expr, $res:expr) => {
+ ::std::result::Result::Ok(($res, $i))
+ };
+}
+
+/// Unconditionally fail to parse anything.
+///
+/// This may be useful in rejecting some arms of a `switch!` parser.
+///
+/// - **Syntax:** `reject!()`
+/// - **Output:** never succeeds
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Item;
+///
+/// // Parse any item, except for a module.
+/// named!(almost_any_item -> Item,
+/// switch!(syn!(Item),
+/// Item::Mod(_) => reject!()
+/// |
+/// ok => value!(ok)
+/// )
+/// );
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! reject {
+ ($i:expr,) => {{
+ let _ = $i;
+ $crate::parse_error()
+ }}
+}
+
+/// Run a series of parsers and produce all of the results in a tuple.
+///
+/// - **Syntax:** `tuple!(A, B, C, ...)`
+/// - **Output:** `(A, B, C, ...)`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Type;
+///
+/// named!(two_types -> (Type, Type), tuple!(syn!(Type), syn!(Type)));
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! tuple {
+ ($i:expr, $($rest:tt)*) => {
+ tuple_parser!($i, (), $($rest)*)
+ };
+}
+
+// Internal parser, do not use directly.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! tuple_parser {
+ ($i:expr, ($($parsed:tt),*), $e:ident, $($rest:tt)*) => {
+ tuple_parser!($i, ($($parsed),*), call!($e), $($rest)*)
+ };
+
+ ($i:expr, (), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) =>
+ tuple_parser!(i, (o), $($rest)*),
+ }
+ };
+
+ ($i:expr, ($($parsed:tt)*), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) =>
+ tuple_parser!(i, ($($parsed)* , o), $($rest)*),
+ }
+ };
+
+ ($i:expr, ($($parsed:tt),*), $e:ident) => {
+ tuple_parser!($i, ($($parsed),*), call!($e))
+ };
+
+ ($i:expr, (), $submac:ident!( $($args:tt)* )) => {
+ $submac!($i, $($args)*)
+ };
+
+ ($i:expr, ($($parsed:expr),*), $submac:ident!( $($args:tt)* )) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) =>
+ ::std::result::Result::Ok((($($parsed),*, o), i)),
+ }
+ };
+
+ ($i:expr, ($($parsed:expr),*)) => {
+ ::std::result::Result::Ok((($($parsed),*), $i))
+ };
+}
+
+/// Run a series of parsers, returning the result of the first one which
+/// succeeds.
+///
+/// Optionally allows for the result to be transformed.
+///
+/// - **Syntax:** `alt!(THING1 | THING2 => { FUNC } | ...)`
+/// - **Output:** `T`, the return type of `THING1` and `FUNC(THING2)` and ...
+///
+/// # Example
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Ident;
+///
+/// // Parse any identifier token, or the `!` token in which case the
+/// // identifier is treated as `"BANG"`.
+/// named!(ident_or_bang -> Ident, alt!(
+/// syn!(Ident)
+/// |
+/// punct!(!) => { |_| "BANG".into() }
+/// ));
+/// #
+/// # fn main() {}
+/// ```
+///
+/// The `alt!` macro is most commonly seen when parsing a syntax tree enum such
+/// as the [`Item`] enum.
+///
+/// [`Item`]: enum.Item.html
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate syn;
+/// #
+/// # use syn::synom::Synom;
+/// #
+/// # struct Item;
+/// #
+/// impl Synom for Item {
+/// named!(parse -> Self, alt!(
+/// # epsilon!() => { |_| unimplemented!() }
+/// # ));
+/// # }
+/// #
+/// # mod example {
+/// # use syn::*;
+/// #
+/// # named!(parse -> Item, alt!(
+/// syn!(ItemExternCrate) => { Item::ExternCrate }
+/// |
+/// syn!(ItemUse) => { Item::Use }
+/// |
+/// syn!(ItemStatic) => { Item::Static }
+/// |
+/// syn!(ItemConst) => { Item::Const }
+/// |
+/// /* ... */
+/// # syn!(ItemFn) => { Item::Fn }
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! alt {
+ ($i:expr, $e:ident | $($rest:tt)*) => {
+ alt!($i, call!($e) | $($rest)*)
+ };
+
+ ($i:expr, $subrule:ident!( $($args:tt)*) | $($rest:tt)*) => {
+ match $subrule!($i, $($args)*) {
+ res @ ::std::result::Result::Ok(_) => res,
+ _ => alt!($i, $($rest)*)
+ }
+ };
+
+ ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr } | $($rest:tt)+) => {
+ match $subrule!($i, $($args)*) {
+ ::std::result::Result::Ok((o, i)) =>
+ ::std::result::Result::Ok(($crate::parsers::invoke($gen, o), i)),
+ ::std::result::Result::Err(_) => alt!($i, $($rest)*),
+ }
+ };
+
+ ($i:expr, $e:ident => { $gen:expr } | $($rest:tt)*) => {
+ alt!($i, call!($e) => { $gen } | $($rest)*)
+ };
+
+ ($i:expr, $e:ident => { $gen:expr }) => {
+ alt!($i, call!($e) => { $gen })
+ };
+
+ ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr }) => {
+ match $subrule!($i, $($args)*) {
+ ::std::result::Result::Ok((o, i)) =>
+ ::std::result::Result::Ok(($crate::parsers::invoke($gen, o), i)),
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ }
+ };
+
+ ($i:expr, $e:ident) => {
+ alt!($i, call!($e))
+ };
+
+ ($i:expr, $subrule:ident!( $($args:tt)*)) => {
+ $subrule!($i, $($args)*)
+ };
+}
+
+/// Run a series of parsers, optionally naming each intermediate result,
+/// followed by a step to combine the intermediate results.
+///
+/// Produces the result of evaluating the final expression in parentheses with
+/// all of the previously named results bound.
+///
+/// - **Syntax:** `do_parse!(name: THING1 >> THING2 >> (RESULT))`
+/// - **Output:** `RESULT`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+/// extern crate proc_macro2;
+///
+/// use syn::Ident;
+/// use syn::token::Paren;
+/// use syn::synom::Synom;
+/// use proc_macro2::TokenStream;
+///
+/// /// Parse a macro invocation that uses `(` `)` parentheses.
+/// ///
+/// /// Example: `stringify!($args)`.
+/// struct Macro {
+/// name: Ident,
+/// bang_token: Token![!],
+/// paren_token: Paren,
+/// tts: TokenStream,
+/// }
+///
+/// impl Synom for Macro {
+/// named!(parse -> Self, do_parse!(
+/// name: syn!(Ident) >>
+/// bang_token: punct!(!) >>
+/// body: parens!(syn!(TokenStream)) >>
+/// (Macro {
+/// name,
+/// bang_token,
+/// paren_token: body.0,
+/// tts: body.1,
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! do_parse {
+ ($i:expr, ( $($rest:expr),* )) => {
+ ::std::result::Result::Ok((( $($rest),* ), $i))
+ };
+
+ ($i:expr, $e:ident >> $($rest:tt)*) => {
+ do_parse!($i, call!($e) >> $($rest)*)
+ };
+
+ ($i:expr, $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((_, i)) =>
+ do_parse!(i, $($rest)*),
+ }
+ };
+
+ ($i:expr, $field:ident : $e:ident >> $($rest:tt)*) => {
+ do_parse!($i, $field: call!($e) >> $($rest)*)
+ };
+
+ ($i:expr, $field:ident : $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) => {
+ let $field = o;
+ do_parse!(i, $($rest)*)
+ },
+ }
+ };
+
+ ($i:expr, mut $field:ident : $e:ident >> $($rest:tt)*) => {
+ do_parse!($i, mut $field: call!($e) >> $($rest)*)
+ };
+
+ ($i:expr, mut $field:ident : $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ ::std::result::Result::Ok((o, i)) => {
+ let mut $field = o;
+ do_parse!(i, $($rest)*)
+ },
+ }
+ };
+}
+
+/// Parse nothing and succeed only if the end of the enclosing block has been
+/// reached.
+///
+/// The enclosing block may be the full input if we are parsing at the top
+/// level, or the surrounding parenthesis/bracket/brace if we are parsing within
+/// those.
+///
+/// - **Syntax:** `input_end!()`
+/// - **Output:** `()`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Expr;
+/// use syn::synom::Synom;
+///
+/// /// Parses any Rust expression followed either by a semicolon or by the end
+/// /// of the input.
+/// ///
+/// /// For example `many0!(syn!(TerminatedExpr))` would successfully parse the
+/// /// following input into three expressions.
+/// ///
+/// /// 1 + 1; second.two(); third!()
+/// ///
+/// /// Similarly within a block, `braced!(many0!(syn!(TerminatedExpr)))` would
+/// /// successfully parse three expressions.
+/// ///
+/// /// { 1 + 1; second.two(); third!() }
+/// struct TerminatedExpr {
+/// expr: Expr,
+/// semi_token: Option<Token![;]>,
+/// }
+///
+/// impl Synom for TerminatedExpr {
+/// named!(parse -> Self, do_parse!(
+/// expr: syn!(Expr) >>
+/// semi_token: alt!(
+/// input_end!() => { |_| None }
+/// |
+/// punct!(;) => { Some }
+/// ) >>
+/// (TerminatedExpr {
+/// expr,
+/// semi_token,
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! input_end {
+ ($i:expr,) => {
+ $crate::parsers::input_end($i)
+ };
+}
+
+// Not a public API
+#[doc(hidden)]
+pub fn input_end(input: Cursor) -> PResult<'static, ()> {
+ if input.eof() {
+ Ok(((), Cursor::empty()))
+ } else {
+ parse_error()
+ }
+}
+
+/// Turn a failed parse into `None` and a successful parse into `Some`.
+///
+/// A failed parse consumes none of the input.
+///
+/// - **Syntax:** `option!(THING)`
+/// - **Output:** `Option<THING>`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::{Label, Block};
+/// use syn::synom::Synom;
+///
+/// /// Parses a Rust loop. Equivalent to syn::ExprLoop.
+/// ///
+/// /// Examples:
+/// /// loop { println!("y"); }
+/// /// 'x: loop { break 'x; }
+/// struct ExprLoop {
+/// label: Option<Label>,
+/// loop_token: Token![loop],
+/// body: Block,
+/// }
+///
+/// impl Synom for ExprLoop {
+/// named!(parse -> Self, do_parse!(
+/// // Loop may or may not have a label.
+/// label: option!(syn!(Label)) >>
+/// loop_token: keyword!(loop) >>
+/// body: syn!(Block) >>
+/// (ExprLoop {
+/// label,
+/// loop_token,
+/// body,
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! option {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Ok((o, i)) =>
+ ::std::result::Result::Ok((Some(o), i)),
+ ::std::result::Result::Err(_) =>
+ ::std::result::Result::Ok((None, $i)),
+ }
+ };
+
+ ($i:expr, $f:expr) => {
+ option!($i, call!($f));
+ };
+}
+
+/// Parses nothing and always succeeds.
+///
+/// This can be useful as a fallthrough case in [`alt!`], as shown below. Also
+/// useful for parsing empty delimiters using [`parens!`] or [`brackets!`] or
+/// [`braces!`] by parsing for example `braces!(epsilon!())` for an empty `{}`.
+///
+/// [`alt!`]: macro.alt.html
+/// [`parens!`]: macro.parens.html
+/// [`brackets!`]: macro.brackets.html
+/// [`braces!`]: macro.braces.html
+///
+/// - **Syntax:** `epsilon!()`
+/// - **Output:** `()`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::synom::Synom;
+///
+/// enum Mutability {
+/// Mutable(Token![mut]),
+/// Immutable,
+/// }
+///
+/// impl Synom for Mutability {
+/// named!(parse -> Self, alt!(
+/// keyword!(mut) => { Mutability::Mutable }
+/// |
+/// epsilon!() => { |_| Mutability::Immutable }
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! epsilon {
+ ($i:expr,) => {
+ ::std::result::Result::Ok(((), $i))
+ };
+}
+
+/// Run a parser, binding the result to a name, and then evaluating an
+/// expression.
+///
+/// Discards the result of the expression and parser.
+///
+/// - **Syntax:** `tap!(NAME : THING => EXPR)`
+/// - **Output:** `()`
+#[doc(hidden)]
+#[macro_export]
+macro_rules! tap {
+ ($i:expr, $name:ident : $submac:ident!( $($args:tt)* ) => $e:expr) => {
+ match $submac!($i, $($args)*) {
+ ::std::result::Result::Ok((o, i)) => {
+ let $name = o;
+ $e;
+ ::std::result::Result::Ok(((), i))
+ }
+ ::std::result::Result::Err(err) =>
+ ::std::result::Result::Err(err),
+ }
+ };
+
+ ($i:expr, $name:ident : $f:expr => $e:expr) => {
+ tap!($i, $name: call!($f) => $e);
+ };
+}
+
+/// Parse any type that implements the `Synom` trait.
+///
+/// Any type implementing [`Synom`] can be used with this parser, whether the
+/// implementation is provided by Syn or is one that you write.
+///
+/// [`Synom`]: synom/trait.Synom.html
+///
+/// - **Syntax:** `syn!(TYPE)`
+/// - **Output:** `TYPE`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::{Ident, Item};
+/// use syn::token::Brace;
+/// use syn::synom::Synom;
+///
+/// /// Parses a module containing zero or more Rust items.
+/// ///
+/// /// Example: `mod m { type Result<T> = ::std::result::Result<T, MyError>; }`
+/// struct SimpleMod {
+/// mod_token: Token![mod],
+/// name: Ident,
+/// brace_token: Brace,
+/// items: Vec<Item>,
+/// }
+///
+/// impl Synom for SimpleMod {
+/// named!(parse -> Self, do_parse!(
+/// mod_token: keyword!(mod) >>
+/// name: syn!(Ident) >>
+/// body: braces!(many0!(syn!(Item))) >>
+/// (SimpleMod {
+/// mod_token,
+/// name,
+/// brace_token: body.0,
+/// items: body.1,
+/// })
+/// ));
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! syn {
+ ($i:expr, $t:ty) => {
+ <$t as $crate::synom::Synom>::parse($i)
+ };
+}
+
+/// Parse inside of `(` `)` parentheses.
+///
+/// This macro parses a set of balanced parentheses and invokes a sub-parser on
+/// the content inside. The sub-parser is required to consume all tokens within
+/// the parentheses in order for this parser to return successfully.
+///
+/// - **Syntax:** `parens!(CONTENT)`
+/// - **Output:** `(token::Paren, CONTENT)`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Expr;
+/// use syn::token::Paren;
+///
+/// /// Parses an expression inside of parentheses.
+/// ///
+/// /// Example: `(1 + 1)`
+/// named!(expr_paren -> (Paren, Expr), parens!(syn!(Expr)));
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! parens {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {
+ $crate::token::Paren::parse($i, |i| $submac!(i, $($args)*))
+ };
+
+ ($i:expr, $f:expr) => {
+ parens!($i, call!($f));
+ };
+}
+
+/// Parse inside of `[` `]` square brackets.
+///
+/// This macro parses a set of balanced brackets and invokes a sub-parser on the
+/// content inside. The sub-parser is required to consume all tokens within the
+/// brackets in order for this parser to return successfully.
+///
+/// - **Syntax:** `brackets!(CONTENT)`
+/// - **Output:** `(token::Bracket, CONTENT)`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Expr;
+/// use syn::token::Bracket;
+///
+/// /// Parses an expression inside of brackets.
+/// ///
+/// /// Example: `[1 + 1]`
+/// named!(expr_paren -> (Bracket, Expr), brackets!(syn!(Expr)));
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! brackets {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {
+ $crate::token::Bracket::parse($i, |i| $submac!(i, $($args)*))
+ };
+
+ ($i:expr, $f:expr) => {
+ brackets!($i, call!($f));
+ };
+}
+
+/// Parse inside of `{` `}` curly braces.
+///
+/// This macro parses a set of balanced braces and invokes a sub-parser on the
+/// content inside. The sub-parser is required to consume all tokens within the
+/// braces in order for this parser to return successfully.
+///
+/// - **Syntax:** `braces!(CONTENT)`
+/// - **Output:** `(token::Brace, CONTENT)`
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate syn;
+///
+/// use syn::Expr;
+/// use syn::token::Brace;
+///
+/// /// Parses an expression inside of braces.
+/// ///
+/// /// Example: `{1 + 1}`
+/// named!(expr_paren -> (Brace, Expr), braces!(syn!(Expr)));
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This macro is available if Syn is built with the `"parsing"` feature.*
+#[macro_export]
+macro_rules! braces {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {
+ $crate::token::Brace::parse($i, |i| $submac!(i, $($args)*))
+ };
+
+ ($i:expr, $f:expr) => {
+ braces!($i, call!($f));
+ };
+}
+
+// Not public API.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! grouped {
+ ($i:expr, $submac:ident!( $($args:tt)* )) => {
+ $crate::token::Group::parse($i, |i| $submac!(i, $($args)*))
+ };
+
+ ($i:expr, $f:expr) => {
+ grouped!($i, call!($f));
+ };
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/syn-0.12.12/src/path.rs
@@ -0,0 +1,572 @@
+// Copyright 2018 Syn Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use punctuated::Punctuated;
+use super::*;
+
+ast_struct! {
+ /// A path at which a named item is exported: `std::collections::HashMap`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct Path {
+ pub leading_colon: Option<Token![::]>,
+ pub segments: Punctuated<PathSegment, Token![::]>,
+ }
+}
+
+impl Path {
+ pub fn global(&self) -> bool {
+ self.leading_colon.is_some()
+ }
+}
+
+/// A helper for printing a self-type qualified path as tokens.
+///
+/// ```rust
+/// extern crate syn;
+/// extern crate quote;
+///
+/// use syn::{QSelf, Path, PathTokens};
+/// use quote::{Tokens, ToTokens};
+///
+/// struct MyNode {
+/// qself: Option<QSelf>,
+/// path: Path,
+/// }
+///
+/// impl ToTokens for MyNode {
+/// fn to_tokens(&self, tokens: &mut Tokens) {
+/// PathTokens(&self.qself, &self.path).to_tokens(tokens);
+/// }
+/// }
+/// #
+/// # fn main() {}
+/// ```
+///
+/// *This type is available if Syn is built with the `"derive"` or `"full"`
+/// feature and the `"printing"` feature.*
+#[cfg(feature = "printing")]
+#[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))]
+#[cfg_attr(feature = "clone-impls", derive(Clone))]
+pub struct PathTokens<'a>(pub &'a Option<QSelf>, pub &'a Path);
+
+impl<T> From<T> for Path
+where
+ T: Into<PathSegment>,
+{
+ fn from(segment: T) -> Self {
+ let mut path = Path {
+ leading_colon: None,
+ segments: Punctuated::new(),
+ };
+ path.segments.push_value(segment.into());
+ path
+ }
+}
+
+ast_struct! {
+ /// A segment of a path together with any path arguments on that segment.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct PathSegment {
+ pub ident: Ident,
+ pub arguments: PathArguments,
+ }
+}
+
+impl<T> From<T> for PathSegment
+where
+ T: Into<Ident>,
+{
+ fn from(ident: T) -> Self {
+ PathSegment {
+ ident: ident.into(),
+ arguments: PathArguments::None,
+ }
+ }
+}
+
+ast_enum! {
+ /// Angle bracketed or parenthesized arguments of a path segment.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ ///
+ /// ## Angle bracketed
+ ///
+ /// The `<'a, T>` in `std::slice::iter<'a, T>`.
+ ///
+ /// ## Parenthesized
+ ///
+ /// The `(A, B) -> C` in `Fn(A, B) -> C`.
+ pub enum PathArguments {
+ None,
+ /// The `<'a, T>` in `std::slice::iter<'a, T>`.
+ AngleBracketed(AngleBracketedGenericArguments),
+ /// The `(A, B) -> C` in `Fn(A, B) -> C`.
+ Parenthesized(ParenthesizedGenericArguments),
+ }
+}
+
+impl Default for PathArguments {
+ fn default() -> Self {
+ PathArguments::None
+ }
+}
+
+impl PathArguments {
+ pub fn is_empty(&self) -> bool {
+ match *self {
+ PathArguments::None => true,
+ PathArguments::AngleBracketed(ref bracketed) => bracketed.args.is_empty(),
+ PathArguments::Parenthesized(_) => false,
+ }
+ }
+}
+
+ast_enum! {
+ /// An individual generic argument, like `'a`, `T`, or `Item = T`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub enum GenericArgument {
+ /// A lifetime argument.
+ Lifetime(Lifetime),
+ /// A type argument.
+ Type(Type),
+ /// A binding (equality constraint) on an associated type: the `Item =
+ /// u8` in `Iterator<Item = u8>`.
+ Binding(Binding),
+ /// A const expression. Must be inside of a block.
+ ///
+ /// NOTE: Identity expressions are represented as Type arguments, as
+ /// they are indistinguishable syntactically.
+ Const(Expr),
+ }
+}
+
+ast_struct! {
+ /// Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K,
+ /// V>`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct AngleBracketedGenericArguments {
+ pub colon2_token: Option<Token![::]>,
+ pub lt_token: Token![<],
+ pub args: Punctuated<GenericArgument, Token![,]>,
+ pub gt_token: Token![>],
+ }
+}
+
+ast_struct! {
+ /// A binding (equality constraint) on an associated type: `Item = u8`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct Binding {
+ pub ident: Ident,
+ pub eq_token: Token![=],
+ pub ty: Type,
+ }
+}
+
+ast_struct! {
+ /// Arguments of a function path segment: the `(A, B) -> C` in `Fn(A,B) ->
+ /// C`.
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct ParenthesizedGenericArguments {
+ pub paren_token: token::Paren,
+ /// `(A, B)`
+ pub inputs: Punctuated<Type, Token![,]>,
+ /// `C`
+ pub output: ReturnType,
+ }
+}
+
+ast_struct! {
+ /// The explicit Self type in a qualified path: the `T` in `<T as
+ /// Display>::fmt`.
+ ///
+ /// The actual path, including the trait and the associated item, is stored
+ /// separately. The `position` field represents the index of the associated
+ /// item qualified with this Self type.
+ ///
+ /// ```text
+ /// <Vec<T> as a::b::Trait>::AssociatedItem
+ /// ^~~~~~ ~~~~~~~~~~~~~~^
+ /// ty position = 3
+ ///
+ /// <Vec<T>>::AssociatedItem
+ /// ^~~~~~ ^
+ /// ty position = 0
+ /// ```
+ ///
+ /// *This type is available if Syn is built with the `"derive"` or `"full"`
+ /// feature.*
+ pub struct QSelf {
+ pub lt_token: Token![<],
+ pub ty: Box<Type>,
+ pub position: usize,
+ pub as_token: Option<Token![as]>,
+ pub gt_token: Token![>],
+ }
+}
+
+#[cfg(feature = "parsing")]
+pub mod parsing {
+ use super::*;
+ use synom::Synom;
+
+ impl Synom for Path {
+ named!(parse -> Self, do_parse!(
+ colon: option!(punct!(::)) >>
+ segments: call!(Punctuated::<PathSegment, Token![::]>::parse_separated_nonempty) >>
+ cond_reduce!(segments.first().map_or(true, |seg| seg.value().ident != "dyn")) >>
+ (Path {
+ leading_colon: colon,
+ segments: segments,
+ })
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("path")
+ }
+ }
+
+ #[cfg(not(feature = "full"))]
+ impl Synom for GenericArgument {
+ named!(parse -> Self, alt!(
+ call!(ty_no_eq_after) => { GenericArgument::Type }
+ |
+ syn!(Lifetime) => { GenericArgument::Lifetime }
+ |
+ syn!(Binding) => { GenericArgument::Binding }
+ ));
+ }
+
+ #[cfg(feature = "full")]
+ impl Synom for GenericArgument {
+ named!(parse -> Self, alt!(
+ call!(ty_no_eq_after) => { GenericArgument::Type }
+ |
+ syn!(Lifetime) => { GenericArgument::Lifetime }
+ |
+ syn!(Binding) => { GenericArgument::Binding }
+ |
+ syn!(ExprLit) => { |l| GenericArgument::Const(Expr::Lit(l)) }
+ |
+ syn!(ExprBlock) => { |b| GenericArgument::Const(Expr::Block(b)) }
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("generic argument")
+ }
+ }
+
+ impl Synom for AngleBracketedGenericArguments {
+ named!(parse -> Self, do_parse!(
+ colon2: option!(punct!(::)) >>
+ lt: punct!(<) >>
+ args: call!(Punctuated::parse_terminated) >>
+ gt: punct!(>) >>
+ (AngleBracketedGenericArguments {
+ colon2_token: colon2,
+ lt_token: lt,
+ args: args,
+ gt_token: gt,
+ })
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("angle bracketed generic arguments")
+ }
+ }
+
+ impl Synom for ParenthesizedGenericArguments {
+ named!(parse -> Self, do_parse!(
+ data: parens!(Punctuated::parse_terminated) >>
+ output: syn!(ReturnType) >>
+ (ParenthesizedGenericArguments {
+ paren_token: data.0,
+ inputs: data.1,
+ output: output,
+ })
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("parenthesized generic arguments: `Foo(A, B, ..) -> T`")
+ }
+ }
+
+ impl Synom for PathSegment {
+ named!(parse -> Self, alt!(
+ do_parse!(
+ ident: syn!(Ident) >>
+ arguments: syn!(AngleBracketedGenericArguments) >>
+ (PathSegment {
+ ident: ident,
+ arguments: PathArguments::AngleBracketed(arguments),
+ })
+ )
+ |
+ mod_style_path_segment
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("path segment")
+ }
+ }
+
+ impl Synom for Binding {
+ named!(parse -> Self, do_parse!(
+ id: syn!(Ident) >>
+ eq: punct!(=) >>
+ ty: syn!(Type) >>
+ (Binding {
+ ident: id,
+ eq_token: eq,
+ ty: ty,
+ })
+ ));
+
+ fn description() -> Option<&'static str> {
+ Some("associated type binding")
+ }
+ }
+
+ impl Path {
+ named!(pub parse_mod_style -> Self, do_parse!(
+ colon: option!(punct!(::)) >>
+ segments: call!(Punctuated::parse_separated_nonempty_with,
+ mod_style_path_segment) >>
+ (Path {
+ leading_colon: colon,
+ segments: segments,
+ })
+ ));
+ }
+
+ named!(mod_style_path_segment -> PathSegment, alt!(
+ syn!(Ident) => { Into::into }
+ |
+ keyword!(super) => { Into::into }
+ |
+ keyword!(self) => { Into::into }
+ |
+ keyword!(Self) => { Into::into }
+ |
+ keyword!(crate) => { Into::into }
+ ));
+
+ named!(pub qpath -> (Option<QSelf>, Path), alt!(
+ map!(syn!(Path), |p| (None, p))
+ |
+ do_parse!(
+ lt: punct!(<) >>
+ this: syn!(Type) >>
+ path: option!(tuple!(keyword!(as), syn!(Path))) >>
+ gt: punct!(>) >>
+ colon2: punct!(::) >>
+ rest: call!(Punctuated::parse_separated_nonempty) >>
+ ({
+ let (pos, as_, path) = match path {
+ Some((as_, mut path)) => {
+ let pos = path.segments.len();
+ path.segments.push_punct(colon2);
+ path.segments.extend(rest.into_pairs());
+ (pos, Some(as_), path)
+ }
+ None => {
+ (0, None, Path {
+ leading_colon: Some(colon2),
+ segments: rest,
+ })
+ }
+ };
+ (Some(QSelf {
+ lt_token: lt,
+ ty: Box::new(this),
+ position: pos,
+ as_token: as_,
+ gt_token: gt,
+ }), path)
+ })
+ )
+ |
+ map!(keyword!(self), |s| (None, s.into()))
+ ));
+
+ named!(pub ty_no_eq_after -> Type, do_parse!(
+ ty: syn!(Type) >>
+ not!(punct!(=)) >>
+ (ty)
+ ));
+}
+
+#[cfg(feature = "printing")]
+mod printing {
+ use super::*;
+ use quote::{ToTokens, Tokens};
+
+ impl ToTokens for Path {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.leading_colon.to_tokens(tokens);
+ self.segments.to_tokens(tokens);
+ }
+ }
+
+ impl ToTokens for PathSegment {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.ident.to_tokens(tokens);
+ self.arguments.to_tokens(tokens);
+ }
+ }
+
+ impl ToTokens for PathArguments {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ match *self {
+ PathArguments::None => {}
+ PathArguments::AngleBracketed(ref arguments) => {
+ arguments.to_tokens(tokens);
+ }
+ PathArguments::Parenthesized(ref arguments) => {
+ arguments.to_tokens(tokens);
+ }
+ }
+ }
+ }
+
+ impl ToTokens for GenericArgument {
+ #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ match *self {
+ GenericArgument::Lifetime(ref lt) => lt.to_tokens(tokens),
+ GenericArgument::Type(ref ty) => ty.to_tokens(tokens),
+ GenericArgument::Binding(ref tb) => tb.to_tokens(tokens),
+ GenericArgument::Const(ref e) => match *e {
+ Expr::Lit(_) => e.to_tokens(tokens),
+
+ // NOTE: We should probably support parsing blocks with only
+ // expressions in them without the full feature for const
+ // generics.
+ #[cfg(feature = "full")]
+ Expr::Block(_) => e.to_tokens(tokens),
+
+ // ERROR CORRECTION: Add braces to make sure that the
+ // generated code is valid.
+ _ => token::Brace::default().surround(tokens, |tokens| {
+ e.to_tokens(tokens);
+ }),
+ },
+ }
+ }
+ }
+
+ impl ToTokens for AngleBracketedGenericArguments {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.colon2_token.to_tokens(tokens);
+ self.lt_token.to_tokens(tokens);
+
+ // Print lifetimes before types and consts, all before bindings,
+ // regardless of their order in self.args.
+ //
+ // TODO: ordering rules for const arguments vs type arguments have
+ // not been settled yet. https://github.com/rust-lang/rust/issues/44580
+ let mut trailing_or_empty = true;
+ for param in self.args.pairs() {
+ if let GenericArgument::Lifetime(_) = **param.value() {
+ param.to_tokens(tokens);
+ trailing_or_empty = param.punct().is_some();
+ }
+ }
+ for param in self.args.pairs() {
+ match **param.value() {
+ GenericArgument::Type(_) | GenericArgument::Const(_) => {
+ if !trailing_or_empty {
+ <Token![,]>::default().to_tokens(tokens);
+ }
+ param.to_tokens(tokens);
+ trailing_or_empty = param.punct().is_some();
+ }
+ GenericArgument::Lifetime(_) | GenericArgument::Binding(_) => {}
+ }
+ }
+ for param in self.args.pairs() {
+ if let GenericArgument::Binding(_) = **param.value() {
+ if !trailing_or_empty {
+ <Token![,]>::default().to_tokens(tokens);
+ trailing_or_empty = true;
+ }
+ param.to_tokens(tokens);
+ }
+ }
+
+ self.gt_token.to_tokens(tokens);
+ }
+ }
+
+ impl ToTokens for Binding {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.ident.to_tokens(tokens);
+ self.eq_token.to_tokens(tokens);
+ self.ty.to_tokens(tokens);
+ }
+ }
+
+ impl ToTokens for ParenthesizedGenericArguments {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.paren_token.surround(tokens, |tokens| {
+ self.inputs.to_tokens(tokens);
+ });
+ self.output.to_tokens(tokens);
+ }
+ }
+
+ impl<'a> ToTokens for PathTokens<'a> {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ let qself = match *self.0 {
+ Some(ref qself) => qself,
+ None => return self.1.to_tokens(tokens),
+ };
+ qself.lt_token.to_tokens(tokens);
+ qself.ty.to_tokens(tokens);
+
+ // XXX: Gross.
+ let pos = if qself.position > 0 && qself.position >= self.1.segments.len() {
+ self.1.segments.len() - 1
+ } else {
+ qself.position
+ };
+ let mut segments = self.1.segments.pairs();
+ if pos > 0 {
+ TokensOrDefault(&qself.as_token).to_tokens(tokens);
+ self.1.leading_colon.to_tokens(tokens);
+ for (i, segment) in segments.by_ref().take(pos).enumerate() {
+ if i + 1 == pos {
+ segment.value().to_tokens(tokens);
+ qself.gt_token.to_tokens(tokens);
+ segment.punct().to_tokens(tokens);
+ } else {
+ segment.to_tokens(tokens);
+ }
+ }
+ } else {
+ qself.gt_token.to_tokens(tokens);
+ self.1.leading_colon.to_tokens(tokens);
+ }
+ for segment in segments {
+ segment.to_tokens(tokens);
+ }
+ }
+ }
+}
copy from third_party/rust/syn/src/punctuated.rs
copy to third_party/rust/syn-0.12.12/src/punctuated.rs
copy from third_party/rust/syn/src/spanned.rs
copy to third_party/rust/syn-0.12.12/src/spanned.rs
copy from third_party/rust/syn/src/synom.rs
copy to third_party/rust/syn-0.12.12/src/synom.rs
copy from third_party/rust/syn/src/token.rs
copy to third_party/rust/syn-0.12.12/src/token.rs
copy from third_party/rust/syn/src/tt.rs
copy to third_party/rust/syn-0.12.12/src/tt.rs
copy from third_party/rust/syn/src/ty.rs
copy to third_party/rust/syn-0.12.12/src/ty.rs
--- a/third_party/rust/syn/.cargo-checksum.json
+++ b/third_party/rust/syn/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"8c4299d297c1f5d0f6afcfedde821e5cdf1893607290af92aebd9b4b86c48386","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"f033c371492a4769d377a8bf1a139adc7bf94ea00595b867a3e234eeab994c8c","README.md":"632c404dd064731af5fd71e643fbba83ced6ac9198497b672139bada194cf41b","src/attr.rs":"35cc8556dd26662d79c3059315de5a5758ce18b697a8ce32361b09ce1a820a0e","src/buffer.rs":"81ca1506c599cfba1136d9fec2d83137f4a4085b341658a4155d978f31b64552","src/data.rs":"d052602339af37df6454a07fd1163e382571d8665529450339cfe55773e308ae","src/derive.rs":"eed8e88cd763e852782b10d2366a81e52d3ec0777676eaa94827ea3b46151134","src/error.rs":"db9f0648e7399cfcaef9c431b452b5012a6056e75c586212e2cfdb1e18b8c69a","src/expr.rs":"274d9f462225432a3ff0c611a1db44b0b3cc6a673b8c8df2a53bd00cf3a5be95","src/file.rs":"43d5b12828a5c2a0bbef7baa56b0b9638575d73d84e0babaf0e85cdc2d573f16","src/gen/fold.rs":"3bf425ce1a461ce527799e2624a311081e35adc133de3acd5195638024a6872f","src/gen/visit.rs":"6f58e84d9b304d8e8493c01ac71d1d36e61c9e18355d60d06e890b94cdb513d0","src/gen/visit_mut.rs":"537dc348ce5a7353d0d0456138043e4ce916c2ca57c90da10500856ac6393dfe","src/gen_helper.rs":"2be46ff201fd53908350bde4d6c8b7dc427dbd156fa538869a9ccbdf6279af04","src/generics.rs":"5dc13558159085b4743d7a0a65f6cfda735c2a23071c588a7dc215834e0c6b44","src/ident.rs":"ea657c29ee5d483ac59664f808fae3e522e18578d86764b7efcceafc6d8236ca","src/item.rs":"f000f831e6f24de60a7ff7e6164f6adc93ae0fb5d0dc5efc6488bb9519f43dd8","src/lib.rs":"dd1212af93788c6a01193d67185b4258a92c7b6c3f34af395f3ed08174117fdd","src/lifetime.rs":"2c92822a1dfc72738b64d787ef9f7ceb1251e689cacb9e780dc784f99b2d9321","src/lit.rs":"7d0eea1b0057d0ae1bce21815b8fe0ee97b0cd287a8d10e4ff74419b7d6fbefe","src/mac.rs":"ec945e4926de028c153c87f1643e8910e53738d8a4b519b74254479e61acabec","src/macros.rs":"b975b110f9b904e5d82bd0222f7cd0398825fcde146c2b98b581daccf2eb8341","src/op.rs":"b9f9ff8027fc65403858d8fed7d0ac3c919d70f97f830fd7532fb22e1dea993b","src/parse_quote.rs":"b0221332823786d664de3e4976cdd3962ca5fa3c1558bb57f9c8810348ded0b0","src/parsers.rs":"9ef1c5e7760a7a4132fe6834dda5871ff9b6513f51243008f710ee4fe973529d","src/path.rs":"01455551da12e8782b4c97ccb8c670d81ea1db1264393a73577535141d5266a8","src/punctuated.rs":"87312dc0d057935774ac64e2c2fdfdae7f693b128c53415d76d78ca377098ced","src/spanned.rs":"9343c288a6d07a0d306c9bd2f332b8eb91fb657f88ec8fbb336ad1b667b583dd","src/synom.rs":"74d8c022ef216f798268999c9c934dca05ad75914d60fc2b445d3a7201826f0d","src/token.rs":"4f16136315cc9ff1e707e80bde148d9471f7e4708c30e07b9c1d3a0bc98805fd","src/tt.rs":"2e10762c00bce15a8e22125bba26c856112e701a82f849aa0d46701e6228823f","src/ty.rs":"0f73cc4626171be4ab2a1de9b2c0c94229055a762ba50ba9ba41b29908447867"},"package":"9e1c669ed757c0ebd04337f6a5bb972d05e0c08fe2540dd3ee3dd9e4daf1604c"}
\ No newline at end of file
+{"files":{"Cargo.toml":"6e30a2a0b1f654eb5baee4a35dd6acc7ba672a9dd390fcc96be14141f3c46957","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"f033c371492a4769d377a8bf1a139adc7bf94ea00595b867a3e234eeab994c8c","README.md":"95ff123a7ebc2968ad9eb5b3bb0f9f2d3d3dca15f32a28432088f9af763cf88f","src/attr.rs":"38e85d2c4e1d7bcf081297d10c6ad6adfd0b15c29285eb01ab71f50cbd19e3a5","src/buffer.rs":"15d2d687102a05dd09cfd1a4bd8c0bf9752dc865606070326ef001e536469233","src/data.rs":"d6514cb3c8f30f72c89abf7118903dfa35887a13e46969de9b170a9661f123a7","src/derive.rs":"eed8e88cd763e852782b10d2366a81e52d3ec0777676eaa94827ea3b46151134","src/error.rs":"db9f0648e7399cfcaef9c431b452b5012a6056e75c586212e2cfdb1e18b8c69a","src/expr.rs":"60d76c1828292b8eacd67dd3aed9d6fbdb696e31ed77390c7224b01bae6d51a4","src/file.rs":"43d5b12828a5c2a0bbef7baa56b0b9638575d73d84e0babaf0e85cdc2d573f16","src/gen/fold.rs":"7bcf7814e6d34b5b7420cb865643f955766448b7e045d16a5188f605d52d6203","src/gen/visit.rs":"a58990558ad865a7cbdd758c35641bd072409e59b743f9fd0fdfd68b995be4f2","src/gen/visit_mut.rs":"68a40b4c34c9968303b43db4bb1cbb2bc6fccf0a36156639f40c1dd2af4f23a2","src/gen_helper.rs":"2be46ff201fd53908350bde4d6c8b7dc427dbd156fa538869a9ccbdf6279af04","src/generics.rs":"2202ba51ba65532af42cbfe70be23a91fb134be433fa21ed129f862832a709a0","src/ident.rs":"8d20690df5778a100c43df0f02d8aec974ac63562e9c7928de0e1954ed83e2e5","src/item.rs":"a42b3316e56fdb7c5cdaf1a839e22a6e7aa29d7cc73e153144c75935fe336cb3","src/lib.rs":"59ee133804c9cccfa35448b421350e30b7a12437476920ddadac9e6664dcb5e7","src/lifetime.rs":"a893013506d23418fbbc1bffcc5d85066de4c5766d693b9451f4a609a70888ba","src/lit.rs":"7b6b4e23dd1a8151a2202bbdd1eda37d0844c065cbb40f4a385c51a627273a7a","src/mac.rs":"ec945e4926de028c153c87f1643e8910e53738d8a4b519b74254479e61acabec","src/macros.rs":"b975b110f9b904e5d82bd0222f7cd0398825fcde146c2b98b581daccf2eb8341","src/op.rs":"b9f9ff8027fc65403858d8fed7d0ac3c919d70f97f830fd7532fb22e1dea993b","src/parse_quote.rs":"b0221332823786d664de3e4976cdd3962ca5fa3c1558bb57f9c8810348ded0b0","src/parsers.rs":"9ef1c5e7760a7a4132fe6834dda5871ff9b6513f51243008f710ee4fe973529d","src/path.rs":"01455551da12e8782b4c97ccb8c670d81ea1db1264393a73577535141d5266a8","src/punctuated.rs":"332277f8867f6ca306e645e440d3582c04e0926f7aa65661c51fb49579530f10","src/spanned.rs":"2624bfac35a6bbe7e628af362772e5cc8d98b9462ec9a8369cf459e431d7ecb4","src/synom.rs":"833d59768e2018706ebe95e3c89c5b6044c5f6306262fe4dc591d59d69058b84","src/token.rs":"af717ca5a0bc404b3351456daa532894697f0f7609f9c0e3d995eeef3f5ff9af","src/tt.rs":"48ec67f4bba2d35c4dd113bb3dc577d34866a72a778bc60bb5f1750ca9b67f0a","src/ty.rs":"9b61ed1b97175036af79eb64b4423c7def2769ed32dc17da16179c0c1393b054"},"package":"91b52877572087400e83d24b9178488541e3d535259e04ff17a63df1e5ceff59"}
\ No newline at end of file
--- a/third_party/rust/syn/Cargo.toml
+++ b/third_party/rust/syn/Cargo.toml
@@ -7,49 +7,53 @@
#
# If you believe there's an error in this file please file an
# issue against the rust-lang/cargo repository. If you're
# editing this file be aware that the upstream Cargo.toml
# will likely look very different (and much more reasonable)
[package]
name = "syn"
-version = "0.12.12"
+version = "0.13.1"
authors = ["David Tolnay <dtolnay@gmail.com>"]
include = ["/Cargo.toml", "/src/**/*.rs", "/README.md", "/LICENSE-APACHE", "/LICENSE-MIT"]
description = "Nom parser for Rust source code"
documentation = "https://docs.rs/syn"
+readme = "README.md"
categories = ["development-tools::procedural-macro-helpers"]
license = "MIT/Apache-2.0"
repository = "https://github.com/dtolnay/syn"
[package.metadata.docs.rs]
all-features = true
[[example]]
name = "dump-syntax"
path = "examples/dump-syntax/main.rs"
required-features = ["full", "parsing", "extra-traits"]
[dependencies.proc-macro2]
-version = "0.2"
+version = "0.3"
+default-features = false
[dependencies.quote]
-version = "0.4"
+version = "0.5"
optional = true
+default-features = false
[dependencies.unicode-xid]
version = "0.1"
[dev-dependencies.rayon]
-version = "0.9"
+version = "1.0.0"
[dev-dependencies.walkdir]
-version = "1.0.1"
+version = "2"
[features]
clone-impls = []
-default = ["derive", "parsing", "printing", "clone-impls"]
+default = ["derive", "parsing", "printing", "clone-impls", "proc-macro"]
derive = []
extra-traits = []
fold = []
full = []
parsing = []
printing = ["quote"]
+proc-macro = ["proc-macro2/proc-macro", "quote/proc-macro"]
visit = []
visit-mut = []
--- a/third_party/rust/syn/README.md
+++ b/third_party/rust/syn/README.md
@@ -1,14 +1,15 @@
Nom parser for Rust source code
===============================
[](https://travis-ci.org/dtolnay/syn)
[](https://crates.io/crates/syn)
-[](https://docs.rs/syn/0.12/syn/)
+[](https://docs.rs/syn/0.13/syn/)
+[](https://blog.rust-lang.org/2017/02/02/Rust-1.15.html)
Syn is a parsing library for parsing a stream of Rust tokens into a syntax tree
of Rust source code.
Currently this library is geared toward the [custom derive] use case but
contains some APIs that may be useful for Rust procedural macros more generally.
[custom derive]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
@@ -36,21 +37,21 @@ contains some APIs that may be useful fo
token. These spans allow a procedural macro to display detailed error messages
pointing to all the right places in the user's code. There is an example of
this below.
- **Feature flags** — Functionality is aggressively feature gated so your
procedural macros enable only what they need, and do not pay in compile time
for all the rest.
-[`syn::File`]: https://docs.rs/syn/0.12/syn/struct.File.html
-[`syn::Item`]: https://docs.rs/syn/0.12/syn/enum.Item.html
-[`syn::Expr`]: https://docs.rs/syn/0.12/syn/enum.Expr.html
-[`syn::Type`]: https://docs.rs/syn/0.12/syn/enum.Type.html
-[`syn::DeriveInput`]: https://docs.rs/syn/0.12/syn/struct.DeriveInput.html
+[`syn::File`]: https://docs.rs/syn/0.13/syn/struct.File.html
+[`syn::Item`]: https://docs.rs/syn/0.13/syn/enum.Item.html
+[`syn::Expr`]: https://docs.rs/syn/0.13/syn/enum.Expr.html
+[`syn::Type`]: https://docs.rs/syn/0.13/syn/enum.Type.html
+[`syn::DeriveInput`]: https://docs.rs/syn/0.13/syn/struct.DeriveInput.html
If you get stuck with anything involving procedural macros in Rust I am happy to
provide help even if the issue is not related to Syn. Please file a ticket in
this repo.
*Version requirement: Syn supports any compiler version back to Rust's very
first support for procedural macros in Rust 1.15.0. Some features especially
around error reporting are only available in newer compilers or on the nightly
@@ -64,18 +65,18 @@ we are deriving. Any time that derive ap
compiler passes their data structure as tokens into our macro. We get to execute
arbitrary Rust code to figure out what to do with those tokens, then hand some
tokens back to the compiler to compile into the user's crate.
[`TokenStream`]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
```toml
[dependencies]
-syn = "0.12"
-quote = "0.4"
+syn = "0.13"
+quote = "0.5"
[lib]
proc-macro = true
```
```rust
extern crate proc_macro;
extern crate syn;
@@ -252,18 +253,18 @@ compiler version supports the features w
[`proc-macro2`]: https://github.com/alexcrichton/proc-macro2
On a nightly compiler, to eliminate the stable shim and use the compiler's
`proc-macro` directly, add `proc-macro2` to your Cargo.toml and set its
`"nightly"` feature which bypasses the stable shim.
```toml
[dependencies]
-syn = "0.12"
-proc-macro2 = { version = "0.2", features = ["nightly"] }
+syn = "0.13"
+proc-macro2 = { version = "0.3", features = ["nightly"] }
```
## License
Licensed under either of
* Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
--- a/third_party/rust/syn/src/attr.rs
+++ b/third_party/rust/syn/src/attr.rs
@@ -6,17 +6,17 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use super::*;
use punctuated::Punctuated;
use std::iter;
-use proc_macro2::{Delimiter, Spacing, TokenNode, TokenStream, TokenTree};
+use proc_macro2::{Delimiter, Spacing, TokenStream, TokenTree};
#[cfg(feature = "extra-traits")]
use std::hash::{Hash, Hasher};
#[cfg(feature = "extra-traits")]
use tt::TokenStreamHelper;
ast_struct! {
/// An attribute like `#[repr(transparent)]`.
@@ -108,114 +108,114 @@ impl Attribute {
if self.tts.is_empty() {
return Some(Meta::Word(*name));
}
let tts = self.tts.clone().into_iter().collect::<Vec<_>>();
if tts.len() == 1 {
- if let TokenNode::Group(Delimiter::Parenthesis, ref ts) = tts[0].kind {
- let tokens = ts.clone().into_iter().collect::<Vec<_>>();
- if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) {
- return Some(Meta::List(MetaList {
- paren_token: token::Paren(tts[0].span),
- ident: *name,
- nested: nested_meta_items,
- }));
- }
+ if let Some(meta) = Attribute::extract_meta_list(*name, &tts[0]) {
+ return Some(meta);
}
}
if tts.len() == 2 {
- if let TokenNode::Op('=', Spacing::Alone) = tts[0].kind {
- if let TokenNode::Literal(ref lit) = tts[1].kind {
- if !lit.to_string().starts_with('/') {
- return Some(Meta::NameValue(MetaNameValue {
- ident: *name,
- eq_token: Token,
- lit: Lit::new(lit.clone(), tts[1].span),
- }));
- }
- } else if let TokenNode::Term(ref term) = tts[1].kind {
- match term.as_str() {
- v @ "true" | v @ "false" => {
- return Some(Meta::NameValue(MetaNameValue {
- ident: *name,
- eq_token: Token,
- lit: Lit::Bool(LitBool { value: v == "true", span: tts[1].span }),
- }));
- },
- _ => {}
- }
- }
+ if let Some(meta) = Attribute::extract_name_value(*name, &tts[0], &tts[1]) {
+ return Some(meta);
}
}
None
}
+
+ fn extract_meta_list(ident: Ident, tt: &TokenTree) -> Option<Meta> {
+ let g = match *tt {
+ TokenTree::Group(ref g) => g,
+ _ => return None,
+ };
+ if g.delimiter() != Delimiter::Parenthesis {
+ return None
+ }
+ let tokens = g.stream().clone().into_iter().collect::<Vec<_>>();
+ let nested = match list_of_nested_meta_items_from_tokens(&tokens) {
+ Some(n) => n,
+ None => return None,
+ };
+ Some(Meta::List(MetaList {
+ paren_token: token::Paren(g.span()),
+ ident: ident,
+ nested: nested,
+ }))
+ }
+
+ fn extract_name_value(ident: Ident, a: &TokenTree, b: &TokenTree) -> Option<Meta> {
+ let a = match *a {
+ TokenTree::Op(ref o) => o,
+ _ => return None,
+ };
+ if a.spacing() != Spacing::Alone {
+ return None
+ }
+ if a.op() != '=' {
+ return None
+ }
+
+ match *b {
+ TokenTree::Literal(ref l) if !l.to_string().starts_with('/') => {
+ Some(Meta::NameValue(MetaNameValue {
+ ident: ident,
+ eq_token: Token]),
+ lit: Lit::new(l.clone()),
+ }))
+ }
+ TokenTree::Term(ref term) => {
+ match term.as_str() {
+ v @ "true" | v @ "false" => {
+ Some(Meta::NameValue(MetaNameValue {
+ ident: ident,
+ eq_token: Token]),
+ lit: Lit::Bool(LitBool {
+ value: v == "true",
+ span: b.span(),
+ }),
+ }))
+ },
+ _ => None ,
+ }
+ }
+ _ => None,
+ }
+ }
}
fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMeta, &[TokenTree])> {
assert!(!tts.is_empty());
- match tts[0].kind {
- TokenNode::Literal(ref lit) => {
+ match tts[0] {
+ TokenTree::Literal(ref lit) => {
if lit.to_string().starts_with('/') {
None
} else {
- let lit = Lit::new(lit.clone(), tts[0].span);
+ let lit = Lit::new(lit.clone());
Some((NestedMeta::Literal(lit), &tts[1..]))
}
}
- TokenNode::Term(sym) => {
- let ident = Ident::new(sym.as_str(), tts[0].span);
+ TokenTree::Term(sym) => {
+ let ident = Ident::new(sym.as_str(), sym.span());
if tts.len() >= 3 {
- if let TokenNode::Op('=', Spacing::Alone) = tts[1].kind {
- if let TokenNode::Literal(ref lit) = tts[2].kind {
- if !lit.to_string().starts_with('/') {
- let pair = MetaNameValue {
- ident: Ident::new(sym.as_str(), tts[0].span),
- eq_token: Token,
- lit: Lit::new(lit.clone(), tts[2].span),
- };
- return Some((Meta::NameValue(pair).into(), &tts[3..]));
- }
- } else if let TokenNode::Term(ref term) = tts[2].kind {
- match term.as_str() {
- v @ "true" | v @ "false" => {
- let pair = MetaNameValue {
- ident: Ident::new(sym.as_str(), tts[0].span),
- eq_token: Token,
- lit: Lit::Bool(LitBool { value: v == "true", span: tts[2].span }),
- };
- return Some((Meta::NameValue(pair).into(), &tts[3..]));
- },
- _ => {}
- }
- }
+ if let Some(meta) = Attribute::extract_name_value(ident, &tts[1], &tts[2]) {
+ return Some((NestedMeta::Meta(meta), &tts[3..]))
}
}
if tts.len() >= 2 {
- if let TokenNode::Group(Delimiter::Parenthesis, ref inner_tts) = tts[1].kind {
- let inner_tts = inner_tts.clone().into_iter().collect::<Vec<_>>();
- return match list_of_nested_meta_items_from_tokens(&inner_tts) {
- Some(nested_meta_items) => {
- let list = MetaList {
- ident: ident,
- paren_token: token::Paren(tts[1].span),
- nested: nested_meta_items,
- };
- Some((Meta::List(list).into(), &tts[2..]))
- }
-
- None => None,
- };
+ if let Some(meta) = Attribute::extract_meta_list(ident, &tts[1]) {
+ return Some((NestedMeta::Meta(meta), &tts[2..]))
}
}
Some((Meta::Word(ident).into(), &tts[1..]))
}
_ => None,
}
@@ -226,18 +226,24 @@ fn list_of_nested_meta_items_from_tokens
) -> Option<Punctuated<NestedMeta, Token![,]>> {
let mut nested_meta_items = Punctuated::new();
let mut first = true;
while !tts.is_empty() {
let prev_comma = if first {
first = false;
None
- } else if let TokenNode::Op(',', Spacing::Alone) = tts[0].kind {
- let tok = Token;
+ } else if let TokenTree::Op(ref op) = tts[0] {
+ if op.spacing() != Spacing::Alone {
+ return None
+ }
+ if op.op() != ',' {
+ return None
+ }
+ let tok = Token]);
tts = &tts[1..];
if tts.is_empty() {
break;
}
Some(tok)
} else {
return None;
};
@@ -391,23 +397,22 @@ where
}
#[cfg(feature = "parsing")]
pub mod parsing {
use super::*;
use buffer::Cursor;
use parse_error;
use synom::PResult;
- use proc_macro2::{Literal, Spacing, Span, TokenNode, TokenTree};
+ use proc_macro2::{Literal, Spacing, Span, TokenTree, Op};
fn eq(span: Span) -> TokenTree {
- TokenTree {
- span: span,
- kind: TokenNode::Op('=', Spacing::Alone),
- }
+ let mut op = Op::new('=', Spacing::Alone);
+ op.set_span(span);
+ op.into()
}
impl Attribute {
named!(pub parse_inner -> Self, alt!(
do_parse!(
pound: punct!(#) >>
bang: punct!(!) >>
path_and_tts: brackets!(tuple!(
@@ -426,17 +431,17 @@ pub mod parsing {
bracket_token: bracket,
}
})
)
|
map!(
call!(lit_doc_comment, Comment::Inner),
|lit| {
- let span = lit.span;
+ let span = lit.span();
Attribute {
style: AttrStyle::Inner(<Token![!]>::new(span)),
path: Ident::new("doc", span).into(),
tts: vec![
eq(span),
lit,
].into_iter().collect(),
is_sugared_doc: true,
@@ -466,17 +471,17 @@ pub mod parsing {
bracket_token: bracket,
}
})
)
|
map!(
call!(lit_doc_comment, Comment::Outer),
|lit| {
- let span = lit.span;
+ let span = lit.span();
Attribute {
style: AttrStyle::Outer,
path: Ident::new("doc", span).into(),
tts: vec![
eq(span),
lit,
].into_iter().collect(),
is_sugared_doc: true,
@@ -490,62 +495,42 @@ pub mod parsing {
enum Comment {
Inner,
Outer,
}
fn lit_doc_comment(input: Cursor, style: Comment) -> PResult<TokenTree> {
match input.literal() {
- Some((span, lit, rest)) => {
+ Some((lit, rest)) => {
let string = lit.to_string();
let ok = match style {
Comment::Inner => string.starts_with("//!") || string.starts_with("/*!"),
Comment::Outer => string.starts_with("///") || string.starts_with("/**"),
};
if ok {
- Ok((
- TokenTree {
- span: span,
- kind: TokenNode::Literal(Literal::string(&string)),
- },
- rest,
- ))
+ let mut new = Literal::string(&string);
+ new.set_span(lit.span());
+ Ok((new.into(), rest))
} else {
parse_error()
}
}
_ => parse_error(),
}
}
}
#[cfg(feature = "printing")]
mod printing {
use super::*;
use quote::{ToTokens, Tokens};
- use proc_macro2::Literal;
impl ToTokens for Attribute {
fn to_tokens(&self, tokens: &mut Tokens) {
- // If this was a sugared doc, emit it in its original form instead of `#[doc = "..."]`
- if self.is_sugared_doc {
- if let Some(Meta::NameValue(ref pair)) = self.interpret_meta() {
- if pair.ident == "doc" {
- if let Lit::Str(ref comment) = pair.lit {
- tokens.append(TokenTree {
- span: comment.span,
- kind: TokenNode::Literal(Literal::doccomment(&comment.value())),
- });
- return;
- }
- }
- }
- }
-
self.pound_token.to_tokens(tokens);
if let AttrStyle::Inner(ref b) = self.style {
b.to_tokens(tokens);
}
self.bracket_token.surround(tokens, |tokens| {
self.path.to_tokens(tokens);
self.tts.to_tokens(tokens);
});
--- a/third_party/rust/syn/src/buffer.rs
+++ b/third_party/rust/syn/src/buffer.rs
@@ -122,33 +122,35 @@
//! #
//! # fn main() {}
//! ```
// This module is heavily commented as it contains the only unsafe code in Syn,
// and caution should be used when editing it. The public-facing interface is
// 100% safe but the implementation is fragile internally.
+#[cfg(feature = "proc-macro")]
use proc_macro as pm;
-use proc_macro2::{Delimiter, Literal, Spacing, Span, Term, TokenNode, TokenStream, TokenTree};
+use proc_macro2::{Delimiter, Literal, Span, Term, TokenStream};
+use proc_macro2::{Group, TokenTree, Op};
use std::ptr;
use std::marker::PhantomData;
#[cfg(synom_verbose_trace)]
use std::fmt::{self, Debug};
/// Internal type which is used instead of `TokenTree` to represent a token tree
/// within a `TokenBuffer`.
enum Entry {
// Mimicking types from proc-macro.
Group(Span, Delimiter, TokenBuffer),
- Term(Span, Term),
- Op(Span, char, Spacing),
- Literal(Span, Literal),
+ Term(Term),
+ Op(Op),
+ Literal(Literal),
// End entries contain a raw pointer to the entry from the containing
// token tree, or null if this is the outermost level.
End(*const Entry),
}
/// A buffer that can be efficiently traversed multiple times, unlike
/// `TokenStream` which requires a deep copy in order to traverse more than
/// once.
@@ -169,30 +171,30 @@ impl TokenBuffer {
// NOTE: DO NOT MUTATE THE `Vec` RETURNED FROM THIS FUNCTION ONCE IT
// RETURNS, THE ADDRESS OF ITS BACKING MEMORY MUST REMAIN STABLE.
fn inner_new(stream: TokenStream, up: *const Entry) -> TokenBuffer {
// Build up the entries list, recording the locations of any Groups
// in the list to be processed later.
let mut entries = Vec::new();
let mut seqs = Vec::new();
for tt in stream {
- match tt.kind {
- TokenNode::Term(sym) => {
- entries.push(Entry::Term(tt.span, sym));
+ match tt {
+ TokenTree::Term(sym) => {
+ entries.push(Entry::Term(sym));
}
- TokenNode::Op(chr, ok) => {
- entries.push(Entry::Op(tt.span, chr, ok));
+ TokenTree::Op(op) => {
+ entries.push(Entry::Op(op));
}
- TokenNode::Literal(lit) => {
- entries.push(Entry::Literal(tt.span, lit));
+ TokenTree::Literal(l) => {
+ entries.push(Entry::Literal(l));
}
- TokenNode::Group(delim, seq_stream) => {
+ TokenTree::Group(g) => {
// Record the index of the interesting entry, and store an
// `End(null)` there temporarially.
- seqs.push((entries.len(), tt.span, delim, seq_stream));
+ seqs.push((entries.len(), g.span(), g.delimiter(), g.stream().clone()));
entries.push(Entry::End(ptr::null()));
}
}
}
// Add an `End` entry to the end with a reference to the enclosing token
// stream which was passed in.
entries.push(Entry::End(up));
@@ -213,16 +215,17 @@ impl TokenBuffer {
entries[idx] = Entry::Group(span, delim, inner);
}
TokenBuffer { data: entries }
}
/// Creates a `TokenBuffer` containing all the tokens from the input
/// `TokenStream`.
+ #[cfg(feature = "proc-macro")]
pub fn new(stream: pm::TokenStream) -> TokenBuffer {
Self::new2(stream.into())
}
/// Creates a `TokenBuffer` containing all the tokens from the input
/// `TokenStream`.
pub fn new2(stream: TokenStream) -> TokenBuffer {
Self::inner_new(stream, ptr::null())
@@ -359,40 +362,40 @@ impl<'a> Cursor<'a> {
}
}
None
}
/// If the cursor is pointing at a `Term`, returns it along with a cursor
/// pointing at the next `TokenTree`.
- pub fn term(mut self) -> Option<(Span, Term, Cursor<'a>)> {
+ pub fn term(mut self) -> Option<(Term, Cursor<'a>)> {
self.ignore_none();
match *self.entry() {
- Entry::Term(span, term) => Some((span, term, unsafe { self.bump() })),
+ Entry::Term(term) => Some((term, unsafe { self.bump() })),
_ => None,
}
}
/// If the cursor is pointing at an `Op`, returns it along with a cursor
/// pointing at the next `TokenTree`.
- pub fn op(mut self) -> Option<(Span, char, Spacing, Cursor<'a>)> {
+ pub fn op(mut self) -> Option<(Op, Cursor<'a>)> {
self.ignore_none();
match *self.entry() {
- Entry::Op(span, op, spacing) => Some((span, op, spacing, unsafe { self.bump() })),
+ Entry::Op(op) => Some((op, unsafe { self.bump() })),
_ => None,
}
}
/// If the cursor is pointing at a `Literal`, return it along with a cursor
/// pointing at the next `TokenTree`.
- pub fn literal(mut self) -> Option<(Span, Literal, Cursor<'a>)> {
+ pub fn literal(mut self) -> Option<(Literal, Cursor<'a>)> {
self.ignore_none();
match *self.entry() {
- Entry::Literal(span, ref lit) => Some((span, lit.clone(), unsafe { self.bump() })),
+ Entry::Literal(ref lit) => Some((lit.clone(), unsafe { self.bump() })),
_ => None,
}
}
/// Copies all remaining tokens visible from this cursor into a
/// `TokenStream`.
pub fn token_stream(self) -> TokenStream {
let mut tts = Vec::new();
@@ -410,49 +413,39 @@ impl<'a> Cursor<'a> {
/// Returns `None` if the cursor has reached the end of its stream.
///
/// This method does not treat `None`-delimited groups as transparent, and
/// will return a `Group(None, ..)` if the cursor is looking at one.
pub fn token_tree(self) -> Option<(TokenTree, Cursor<'a>)> {
let tree = match *self.entry() {
Entry::Group(span, delim, ref buf) => {
let stream = buf.begin().token_stream();
- TokenTree {
- span: span,
- kind: TokenNode::Group(delim, stream),
- }
+ let mut g = Group::new(delim, stream);
+ g.set_span(span);
+ TokenTree::from(g)
}
- Entry::Literal(span, ref lit) => TokenTree {
- span: span,
- kind: TokenNode::Literal(lit.clone()),
- },
- Entry::Term(span, sym) => TokenTree {
- span: span,
- kind: TokenNode::Term(sym),
- },
- Entry::Op(span, chr, spacing) => TokenTree {
- span: span,
- kind: TokenNode::Op(chr, spacing),
- },
+ Entry::Literal(ref lit) => lit.clone().into(),
+ Entry::Term(term) => term.into(),
+ Entry::Op(op) => op.into(),
Entry::End(..) => {
return None;
}
};
Some((tree, unsafe { self.bump() }))
}
/// Returns the `Span` of the current token, or `Span::call_site()` if this
/// cursor points to eof.
pub fn span(self) -> Span {
match *self.entry() {
- Entry::Group(span, ..)
- | Entry::Literal(span, ..)
- | Entry::Term(span, ..)
- | Entry::Op(span, ..) => span,
+ Entry::Group(span, ..) => span,
+ Entry::Literal(ref l) => l.span(),
+ Entry::Term(t) => t.span(),
+ Entry::Op(o) => o.span(),
Entry::End(..) => Span::call_site(),
}
}
}
// We do a custom implementation for `Debug` as the default implementation is
// pretty useless.
#[cfg(synom_verbose_trace)]
--- a/third_party/rust/syn/src/data.rs
+++ b/third_party/rust/syn/src/data.rs
@@ -66,28 +66,28 @@ ast_enum_of_structs! {
}
impl Fields {
/// Get an iterator over the [`Field`] items in this object. This iterator
/// can be used to iterate over a named or unnamed struct or variant's
/// fields uniformly.
///
/// [`Field`]: struct.Field.html
- pub fn iter(&self) -> punctuated::Iter<Field, Token![,]> {
+ pub fn iter(&self) -> punctuated::Iter<Field> {
match *self {
Fields::Unit => punctuated::Iter::private_empty(),
Fields::Named(ref f) => f.named.iter(),
Fields::Unnamed(ref f) => f.unnamed.iter(),
}
}
}
impl<'a> IntoIterator for &'a Fields {
type Item = &'a Field;
- type IntoIter = punctuated::Iter<'a, Field, Token![,]>;
+ type IntoIter = punctuated::Iter<'a, Field>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
ast_struct! {
/// A field of a struct or enum variant.
@@ -129,28 +129,26 @@ ast_enum_of_structs! {
/// A public visibility level: `pub`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Public(VisPublic {
pub pub_token: Token![pub],
}),
- /// A crate-level visibility: `pub(crate)`.
+ /// A crate-level visibility: `crate`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Crate(VisCrate {
- pub pub_token: Token![pub],
- pub paren_token: token::Paren,
pub crate_token: Token![crate],
}),
/// A visibility level restricted to some path: `pub(self)` or
- /// `pub(super)` or `pub(in some::module)`.
+ /// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Restricted(VisRestricted {
pub pub_token: Token![pub],
pub paren_token: token::Paren,
pub in_token: Option<Token![in]>,
pub path: Box<Path>,
@@ -250,23 +248,30 @@ pub mod parsing {
));
}
impl Synom for Visibility {
named!(parse -> Self, alt!(
do_parse!(
pub_token: keyword!(pub) >>
other: parens!(keyword!(crate)) >>
- (Visibility::Crate(VisCrate {
+ (Visibility::Restricted(VisRestricted {
pub_token: pub_token,
paren_token: other.0,
- crate_token: other.1,
+ in_token: None,
+ path: Box::new(other.1.into()),
}))
)
|
+ keyword!(crate) => { |tok| {
+ Visibility::Crate(VisCrate {
+ crate_token: tok,
+ })
+ } }
+ |
do_parse!(
pub_token: keyword!(pub) >>
other: parens!(keyword!(self)) >>
(Visibility::Restricted(VisRestricted {
pub_token: pub_token,
paren_token: other.0,
in_token: None,
path: Box::new(other.1.into()),
@@ -362,27 +367,24 @@ mod printing {
impl ToTokens for VisPublic {
fn to_tokens(&self, tokens: &mut Tokens) {
self.pub_token.to_tokens(tokens)
}
}
impl ToTokens for VisCrate {
fn to_tokens(&self, tokens: &mut Tokens) {
- self.pub_token.to_tokens(tokens);
- self.paren_token.surround(tokens, |tokens| {
- self.crate_token.to_tokens(tokens);
- })
+ self.crate_token.to_tokens(tokens);
}
}
impl ToTokens for VisRestricted {
fn to_tokens(&self, tokens: &mut Tokens) {
self.pub_token.to_tokens(tokens);
self.paren_token.surround(tokens, |tokens| {
- // XXX: If we have a path which is not "self" or "super",
- // automatically add the "in" token.
+ // XXX: If we have a path which is not "self" or "super" or
+ // "crate", automatically add the "in" token.
self.in_token.to_tokens(tokens);
self.path.to_tokens(tokens);
});
}
}
}
--- a/third_party/rust/syn/src/expr.rs
+++ b/third_party/rust/syn/src/expr.rs
@@ -237,17 +237,17 @@ ast_enum_of_structs! {
/// The `else` branch expression may only be an `If`, `IfLet`, or
/// `Block` expression, not any of the other types of expression.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub IfLet(ExprIfLet #full {
pub attrs: Vec<Attribute>,
pub if_token: Token![if],
pub let_token: Token![let],
- pub pat: Box<Pat>,
+ pub pats: Punctuated<Pat, Token![|]>,
pub eq_token: Token![=],
pub expr: Box<Expr>,
pub then_branch: Block,
pub else_branch: Option<(Token![else], Box<Expr>)>,
}),
/// A while loop: `while expr { ... }`.
///
@@ -263,17 +263,17 @@ ast_enum_of_structs! {
/// A while-let loop: `while let pat = expr { ... }`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub WhileLet(ExprWhileLet #full {
pub attrs: Vec<Attribute>,
pub label: Option<Label>,
pub while_token: Token![while],
pub let_token: Token![let],
- pub pat: Box<Pat>,
+ pub pats: Punctuated<Pat, Token![|]>,
pub eq_token: Token![=],
pub expr: Box<Expr>,
pub body: Block,
}),
/// A for loop: `for pat in expr { ... }`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
@@ -308,16 +308,17 @@ ast_enum_of_structs! {
pub arms: Vec<Arm>,
}),
/// A closure expression: `|a, b| a + b`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub Closure(ExprClosure #full {
pub attrs: Vec<Attribute>,
+ pub movability: Option<Token![static]>,
pub capture: Option<Token![move]>,
pub or1_token: Token![|],
pub inputs: Punctuated<FnArg, Token![,]>,
pub or2_token: Token![|],
pub output: ReturnType,
pub body: Box<Expr>,
}),
@@ -401,17 +402,17 @@ ast_enum_of_structs! {
pub attrs: Vec<Attribute>,
pub qself: Option<QSelf>,
pub path: Path,
}),
/// A referencing operation: `&a` or `&mut a`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
- pub AddrOf(ExprAddrOf #full {
+ pub Reference(ExprReference #full {
pub attrs: Vec<Attribute>,
pub and_token: Token![&],
pub mutability: Option<Token![mut]>,
pub expr: Box<Expr>,
}),
/// A `break`, with an optional label to break and an optional
/// expression.
@@ -584,17 +585,17 @@ impl Expr {
| Expr::Unsafe(ExprUnsafe { ref mut attrs, .. })
| Expr::Block(ExprBlock { ref mut attrs, .. })
| Expr::Assign(ExprAssign { ref mut attrs, .. })
| Expr::AssignOp(ExprAssignOp { ref mut attrs, .. })
| Expr::Field(ExprField { ref mut attrs, .. })
| Expr::Index(ExprIndex { ref mut attrs, .. })
| Expr::Range(ExprRange { ref mut attrs, .. })
| Expr::Path(ExprPath { ref mut attrs, .. })
- | Expr::AddrOf(ExprAddrOf { ref mut attrs, .. })
+ | Expr::Reference(ExprReference { ref mut attrs, .. })
| Expr::Break(ExprBreak { ref mut attrs, .. })
| Expr::Continue(ExprContinue { ref mut attrs, .. })
| Expr::Return(ExprReturn { ref mut attrs, .. })
| Expr::Macro(ExprMacro { ref mut attrs, .. })
| Expr::Struct(ExprStruct { ref mut attrs, .. })
| Expr::Repeat(ExprRepeat { ref mut attrs, .. })
| Expr::Paren(ExprParen { ref mut attrs, .. })
| Expr::Group(ExprGroup { ref mut attrs, .. })
@@ -634,17 +635,17 @@ ast_struct! {
}
}
impl From<usize> for Index {
fn from(index: usize) -> Index {
assert!(index < std::u32::MAX as usize);
Index {
index: index as u32,
- span: Span::def_site(),
+ span: Span::call_site(),
}
}
}
#[cfg(feature = "extra-traits")]
impl Eq for Index {}
#[cfg(feature = "extra-traits")]
@@ -758,17 +759,17 @@ ast_enum! {
#[cfg(feature = "full")]
ast_struct! {
/// A local `let` binding: `let x: u64 = s.parse()?`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub struct Local {
pub attrs: Vec<Attribute>,
pub let_token: Token![let],
- pub pat: Box<Pat>,
+ pub pats: Punctuated<Pat, Token![|]>,
pub ty: Option<(Token![:], Box<Type>)>,
pub init: Option<(Token![=], Box<Expr>)>,
pub semi_token: Token![;],
}
}
#[cfg(feature = "full")]
ast_enum_of_structs! {
@@ -948,19 +949,20 @@ ast_struct! {
/// }
/// # false
/// # }
/// ```
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub struct Arm {
pub attrs: Vec<Attribute>,
+ pub leading_vert: Option<Token![|]>,
pub pats: Punctuated<Pat, Token![|]>,
pub guard: Option<(Token![if], Box<Expr>)>,
- pub rocket_token: Token![=>],
+ pub fat_arrow_token: Token![=>],
pub body: Box<Expr>,
pub comma: Option<Token![,]>,
}
}
#[cfg(feature = "full")]
ast_enum! {
/// Limit types of a range, inclusive or exclusive.
@@ -1397,17 +1399,17 @@ pub mod parsing {
expr: Box::new(expr),
}.into())
)
|
do_parse!(
and: punct!(&) >>
mutability: option!(keyword!(mut)) >>
expr: call!(unary_expr, allow_struct, true) >>
- (ExprAddrOf {
+ (ExprReference {
attrs: Vec::new(),
and_token: and,
mutability: mutability,
expr: Box::new(expr),
}.into())
)
|
do_parse!(
@@ -1751,24 +1753,24 @@ pub mod parsing {
}
}
#[cfg(feature = "full")]
impl Synom for ExprIfLet {
named!(parse -> Self, do_parse!(
if_: keyword!(if) >>
let_: keyword!(let) >>
- pat: syn!(Pat) >>
+ pats: call!(Punctuated::parse_separated_nonempty) >>
eq: punct!(=) >>
cond: expr_no_struct >>
then_block: braces!(Block::parse_within) >>
else_block: option!(else_block) >>
(ExprIfLet {
attrs: Vec::new(),
- pat: Box::new(pat),
+ pats: pats,
let_token: let_,
eq_token: eq,
expr: Box::new(cond),
then_branch: Block {
brace_token: then_block.0,
stmts: then_block.1,
},
if_token: if_,
@@ -1926,49 +1928,52 @@ pub mod parsing {
Some("`yield` expression")
}
}
#[cfg(feature = "full")]
impl Synom for Arm {
named!(parse -> Self, do_parse!(
attrs: many0!(Attribute::parse_outer) >>
+ leading_vert: option!(punct!(|)) >>
pats: call!(Punctuated::parse_separated_nonempty) >>
guard: option!(tuple!(keyword!(if), syn!(Expr))) >>
- rocket: punct!(=>) >>
+ fat_arrow: punct!(=>) >>
body: do_parse!(
expr: alt!(expr_nosemi | syn!(Expr)) >>
comma: switch!(value!(arm_expr_requires_comma(&expr)),
true => alt!(
input_end!() => { |_| None }
|
punct!(,) => { Some }
)
|
false => option!(punct!(,))
) >>
(expr, comma)
) >>
(Arm {
- rocket_token: rocket,
+ fat_arrow_token: fat_arrow,
attrs: attrs,
+ leading_vert: leading_vert,
pats: pats,
guard: guard.map(|(if_, guard)| (if_, Box::new(guard))),
body: Box::new(body.0),
comma: body.1,
})
));
fn description() -> Option<&'static str> {
Some("`match` arm")
}
}
#[cfg(feature = "full")]
named!(expr_closure(allow_struct: bool) -> Expr, do_parse!(
+ movability: option!(keyword!(static)) >>
capture: option!(keyword!(move)) >>
or1: punct!(|) >>
inputs: call!(Punctuated::parse_terminated_with, fn_arg) >>
or2: punct!(|) >>
ret_and_body: alt!(
do_parse!(
arrow: punct!(->) >>
ty: syn!(Type) >>
@@ -1979,16 +1984,17 @@ pub mod parsing {
block: body,
}))
)
|
map!(ambiguous_expr!(allow_struct), |e| (ReturnType::Default, e))
) >>
(ExprClosure {
attrs: Vec::new(),
+ movability: movability,
capture: capture,
or1_token: or1,
inputs: inputs,
or2_token: or2,
output: ret_and_body.0,
body: Box::new(ret_and_body.1),
}.into())
));
@@ -2032,26 +2038,26 @@ pub mod parsing {
}
#[cfg(feature = "full")]
impl Synom for ExprWhileLet {
named!(parse -> Self, do_parse!(
label: option!(syn!(Label)) >>
while_: keyword!(while) >>
let_: keyword!(let) >>
- pat: syn!(Pat) >>
+ pats: call!(Punctuated::parse_separated_nonempty) >>
eq: punct!(=) >>
value: expr_no_struct >>
while_block: syn!(Block) >>
(ExprWhileLet {
attrs: Vec::new(),
eq_token: eq,
let_token: let_,
while_token: while_,
- pat: Box::new(pat),
+ pats: pats,
expr: Box::new(value),
body: while_block,
label: label,
})
));
fn description() -> Option<&'static str> {
Some("`while let` expression")
@@ -2373,24 +2379,24 @@ pub mod parsing {
semi_token: semi,
})))
));
#[cfg(feature = "full")]
named!(stmt_local -> Stmt, do_parse!(
attrs: many0!(Attribute::parse_outer) >>
let_: keyword!(let) >>
- pat: syn!(Pat) >>
+ pats: call!(Punctuated::parse_separated_nonempty) >>
ty: option!(tuple!(punct!(:), syn!(Type))) >>
init: option!(tuple!(punct!(=), syn!(Expr))) >>
semi: punct!(;) >>
(Stmt::Local(Local {
attrs: attrs,
let_token: let_,
- pat: Box::new(pat),
+ pats: pats,
ty: ty.map(|(colon, ty)| (colon, Box::new(ty))),
init: init.map(|(eq, expr)| (eq, Box::new(expr))),
semi_token: semi,
}))
));
#[cfg(feature = "full")]
named!(stmt_item -> Stmt, map!(syn!(Item), |i| Stmt::Item(i)));
@@ -2612,17 +2618,17 @@ pub mod parsing {
}
#[cfg(feature = "full")]
impl Synom for Index {
named!(parse -> Self, do_parse!(
lit: syn!(LitInt) >>
({
if let IntSuffix::None = lit.suffix() {
- Index { index: lit.value() as u32, span: lit.span }
+ Index { index: lit.value() as u32, span: lit.span() }
} else {
return parse_error();
}
})
));
fn description() -> Option<&'static str> {
Some("field index")
@@ -2808,17 +2814,17 @@ pub mod parsing {
}
#[cfg(feature = "printing")]
mod printing {
use super::*;
#[cfg(feature = "full")]
use attr::FilterAttrs;
use quote::{ToTokens, Tokens};
- use proc_macro2::{Literal, TokenNode, TokenTree};
+ use proc_macro2::Literal;
// If the given expression is a bare `ExprStruct`, wraps it in parenthesis
// before appending it to `Tokens`.
#[cfg(feature = "full")]
fn wrap_bare_struct(tokens: &mut Tokens, e: &Expr) {
if let Expr::Struct(_) = *e {
token::Paren::default().surround(tokens, |tokens| {
e.to_tokens(tokens);
@@ -2999,17 +3005,17 @@ mod printing {
}
#[cfg(feature = "full")]
impl ToTokens for ExprIfLet {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
self.if_token.to_tokens(tokens);
self.let_token.to_tokens(tokens);
- self.pat.to_tokens(tokens);
+ self.pats.to_tokens(tokens);
self.eq_token.to_tokens(tokens);
wrap_bare_struct(tokens, &self.expr);
self.then_branch.to_tokens(tokens);
maybe_wrap_else(tokens, &self.else_branch);
}
}
#[cfg(feature = "full")]
@@ -3025,17 +3031,17 @@ mod printing {
#[cfg(feature = "full")]
impl ToTokens for ExprWhileLet {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
self.label.to_tokens(tokens);
self.while_token.to_tokens(tokens);
self.let_token.to_tokens(tokens);
- self.pat.to_tokens(tokens);
+ self.pats.to_tokens(tokens);
self.eq_token.to_tokens(tokens);
wrap_bare_struct(tokens, &self.expr);
self.body.to_tokens(tokens);
}
}
#[cfg(feature = "full")]
impl ToTokens for ExprForLoop {
@@ -3098,16 +3104,17 @@ mod printing {
self.expr.to_tokens(tokens);
}
}
#[cfg(feature = "full")]
impl ToTokens for ExprClosure {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
+ self.movability.to_tokens(tokens);
self.capture.to_tokens(tokens);
self.or1_token.to_tokens(tokens);
for input in self.inputs.pairs() {
match **input.value() {
FnArg::Captured(ArgCaptured {
ref pat,
ty: Type::Infer(_),
..
@@ -3177,20 +3184,19 @@ mod printing {
Member::Named(ident) => ident.to_tokens(tokens),
Member::Unnamed(ref index) => index.to_tokens(tokens),
}
}
}
impl ToTokens for Index {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(Literal::integer(i64::from(self.index))),
- });
+ let mut lit = Literal::i64_unsuffixed(i64::from(self.index));
+ lit.set_span(self.span);
+ tokens.append(lit);
}
}
impl ToTokens for ExprIndex {
fn to_tokens(&self, tokens: &mut Tokens) {
attrs_to_tokens(&self.attrs, tokens);
self.expr.to_tokens(tokens);
self.bracket_token.surround(tokens, |tokens| {
@@ -3215,17 +3221,17 @@ mod printing {
impl ToTokens for ExprPath {
fn to_tokens(&self, tokens: &mut Tokens) {
attrs_to_tokens(&self.attrs, tokens);
::PathTokens(&self.qself, &self.path).to_tokens(tokens)
}
}
#[cfg(feature = "full")]
- impl ToTokens for ExprAddrOf {
+ impl ToTokens for ExprReference {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
self.and_token.to_tokens(tokens);
self.mutability.to_tokens(tokens);
self.expr.to_tokens(tokens);
}
}
@@ -3345,22 +3351,23 @@ mod printing {
}
}
}
#[cfg(feature = "full")]
impl ToTokens for Arm {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(&self.attrs);
+ self.leading_vert.to_tokens(tokens);
self.pats.to_tokens(tokens);
if let Some((ref if_token, ref guard)) = self.guard {
if_token.to_tokens(tokens);
guard.to_tokens(tokens);
}
- self.rocket_token.to_tokens(tokens);
+ self.fat_arrow_token.to_tokens(tokens);
self.body.to_tokens(tokens);
self.comma.to_tokens(tokens);
}
}
#[cfg(feature = "full")]
impl ToTokens for PatWild {
fn to_tokens(&self, tokens: &mut Tokens) {
@@ -3553,17 +3560,17 @@ mod printing {
}
}
#[cfg(feature = "full")]
impl ToTokens for Local {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
self.let_token.to_tokens(tokens);
- self.pat.to_tokens(tokens);
+ self.pats.to_tokens(tokens);
if let Some((ref colon_token, ref ty)) = self.ty {
colon_token.to_tokens(tokens);
ty.to_tokens(tokens);
}
if let Some((ref eq_token, ref init)) = self.init {
eq_token.to_tokens(tokens);
init.to_tokens(tokens);
}
--- a/third_party/rust/syn/src/gen/fold.rs
+++ b/third_party/rust/syn/src/gen/fold.rs
@@ -71,18 +71,16 @@ fn fold_data_enum(&mut self, i: DataEnum
fn fold_data_struct(&mut self, i: DataStruct) -> DataStruct { fold_data_struct(self, i) }
# [ cfg ( feature = "derive" ) ]
fn fold_data_union(&mut self, i: DataUnion) -> DataUnion { fold_data_union(self, i) }
# [ cfg ( feature = "derive" ) ]
fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput { fold_derive_input(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr(&mut self, i: Expr) -> Expr { fold_expr(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn fold_expr_addr_of(&mut self, i: ExprAddrOf) -> ExprAddrOf { fold_expr_addr_of(self, i) }
-# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray { fold_expr_array(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign { fold_expr_assign(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp { fold_expr_assign_op(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary { fold_expr_binary(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -127,16 +125,18 @@ fn fold_expr_match(&mut self, i: ExprMat
fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall { fold_expr_method_call(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen { fold_expr_paren(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath { fold_expr_path(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange { fold_expr_range(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
+fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference { fold_expr_reference(self, i) }
+# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat { fold_expr_repeat(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn { fold_expr_return(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct { fold_expr_struct(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry { fold_expr_try(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -389,20 +389,24 @@ fn fold_type_trait_object(&mut self, i:
fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple { fold_type_tuple(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_type_verbatim(&mut self, i: TypeVerbatim) -> TypeVerbatim { fold_type_verbatim(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_un_op(&mut self, i: UnOp) -> UnOp { fold_un_op(self, i) }
# [ cfg ( feature = "full" ) ]
fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob { fold_use_glob(self, i) }
# [ cfg ( feature = "full" ) ]
-fn fold_use_list(&mut self, i: UseList) -> UseList { fold_use_list(self, i) }
+fn fold_use_group(&mut self, i: UseGroup) -> UseGroup { fold_use_group(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn fold_use_name(&mut self, i: UseName) -> UseName { fold_use_name(self, i) }
# [ cfg ( feature = "full" ) ]
fn fold_use_path(&mut self, i: UsePath) -> UsePath { fold_use_path(self, i) }
# [ cfg ( feature = "full" ) ]
+fn fold_use_rename(&mut self, i: UseRename) -> UseRename { fold_use_rename(self, i) }
+# [ cfg ( feature = "full" ) ]
fn fold_use_tree(&mut self, i: UseTree) -> UseTree { fold_use_tree(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_variant(&mut self, i: Variant) -> Variant { fold_variant(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate { fold_vis_crate(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic { fold_vis_public(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -414,17 +418,18 @@ fn fold_where_clause(&mut self, i: Where
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate { fold_where_predicate(self, i) }
}
macro_rules! fold_span_only {
($f:ident : $t:ident) => {
pub fn $f<V: Fold + ?Sized>(_visitor: &mut V, mut _i: $t) -> $t {
- _i.span = _visitor.fold_span(_i.span);
+ let span = _visitor.fold_span(_i.span());
+ _i.set_span(span);
_i
}
}
}
fold_span_only!(fold_ident: Ident);
#[cfg(any(feature = "full", feature = "derive"))]
fold_span_only!(fold_lifetime: Lifetime);
@@ -480,22 +485,23 @@ pub fn fold_arg_self_ref<V: Fold + ?Size
mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
self_token: Token ! [ self ](tokens_helper(_visitor, &(_i . self_token).0)),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn fold_arm<V: Fold + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
Arm {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ leading_vert: (_i . leading_vert).map(|it| { Token ! [ | ](tokens_helper(_visitor, &(it).0)) }),
pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
guard: (_i . guard).map(|it| { (
Token ! [ if ](tokens_helper(_visitor, &(( it ) . 0).0)),
Box::new(_visitor.fold_expr(* ( it ) . 1)),
) }),
- rocket_token: Token ! [ => ](tokens_helper(_visitor, &(_i . rocket_token).0)),
+ fat_arrow_token: Token ! [ => ](tokens_helper(_visitor, &(_i . fat_arrow_token).0)),
body: Box::new(_visitor.fold_expr(* _i . body)),
comma: (_i . comma).map(|it| { Token ! [ , ](tokens_helper(_visitor, &(it).0)) }),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_attr_style<V: Fold + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> AttrStyle {
match _i {
AttrStyle::Outer => { AttrStyle::Outer }
@@ -909,19 +915,19 @@ pub fn fold_expr<V: Fold + ?Sized>(_visi
full!(_visitor.fold_expr_range(_binding_0)),
)
}
Expr::Path(_binding_0, ) => {
Expr::Path (
_visitor.fold_expr_path(_binding_0),
)
}
- Expr::AddrOf(_binding_0, ) => {
- Expr::AddrOf (
- full!(_visitor.fold_expr_addr_of(_binding_0)),
+ Expr::Reference(_binding_0, ) => {
+ Expr::Reference (
+ full!(_visitor.fold_expr_reference(_binding_0)),
)
}
Expr::Break(_binding_0, ) => {
Expr::Break (
full!(_visitor.fold_expr_break(_binding_0)),
)
}
Expr::Continue(_binding_0, ) => {
@@ -977,25 +983,16 @@ pub fn fold_expr<V: Fold + ?Sized>(_visi
Expr::Verbatim(_binding_0, ) => {
Expr::Verbatim (
_visitor.fold_expr_verbatim(_binding_0),
)
}
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn fold_expr_addr_of<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAddrOf) -> ExprAddrOf {
- ExprAddrOf {
- attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
- and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
- mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
- expr: Box::new(_visitor.fold_expr(* _i . expr)),
- }
-}
-# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_expr_array<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
ExprArray {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
elems: FoldHelper::lift(_i . elems, |it| { _visitor.fold_expr(it) }),
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -1075,16 +1072,17 @@ pub fn fold_expr_catch<V: Fold + ?Sized>
catch_token: Token ! [ catch ](tokens_helper(_visitor, &(_i . catch_token).0)),
block: _visitor.fold_block(_i . block),
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_expr_closure<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
ExprClosure {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ movability: (_i . movability).map(|it| { Token ! [ static ](tokens_helper(_visitor, &(it).0)) }),
capture: (_i . capture).map(|it| { Token ! [ move ](tokens_helper(_visitor, &(it).0)) }),
or1_token: Token ! [ | ](tokens_helper(_visitor, &(_i . or1_token).0)),
inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_fn_arg(it) }),
or2_token: Token ! [ | ](tokens_helper(_visitor, &(_i . or2_token).0)),
output: _visitor.fold_return_type(_i . output),
body: Box::new(_visitor.fold_expr(* _i . body)),
}
}
@@ -1139,17 +1137,17 @@ pub fn fold_expr_if<V: Fold + ?Sized>(_v
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_expr_if_let<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIfLet) -> ExprIfLet {
ExprIfLet {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
if_token: Token ! [ if ](tokens_helper(_visitor, &(_i . if_token).0)),
let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
+ pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i . eq_token).0)),
expr: Box::new(_visitor.fold_expr(* _i . expr)),
then_branch: _visitor.fold_block(_i . then_branch),
else_branch: (_i . else_branch).map(|it| { (
Token ! [ else ](tokens_helper(_visitor, &(( it ) . 0).0)),
Box::new(_visitor.fold_expr(* ( it ) . 1)),
) }),
}
@@ -1238,16 +1236,25 @@ pub fn fold_expr_range<V: Fold + ?Sized>
ExprRange {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
from: (_i . from).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
limits: _visitor.fold_range_limits(_i . limits),
to: (_i . to).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
+pub fn fold_expr_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReference) -> ExprReference {
+ ExprReference {
+ attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
+ mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
+ expr: Box::new(_visitor.fold_expr(* _i . expr)),
+ }
+}
+# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_expr_repeat<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
ExprRepeat {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
expr: Box::new(_visitor.fold_expr(* _i . expr)),
semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
len: Box::new(_visitor.fold_expr(* _i . len)),
}
@@ -1330,17 +1337,17 @@ pub fn fold_expr_while<V: Fold + ?Sized>
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_expr_while_let<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprWhileLet) -> ExprWhileLet {
ExprWhileLet {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
label: (_i . label).map(|it| { _visitor.fold_label(it) }),
while_token: Token ! [ while ](tokens_helper(_visitor, &(_i . while_token).0)),
let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
+ pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i . eq_token).0)),
expr: Box::new(_visitor.fold_expr(* _i . expr)),
body: _visitor.fold_block(_i . body),
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_expr_yield<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield {
ExprYield {
@@ -1950,17 +1957,16 @@ pub fn fold_item_union<V: Fold + ?Sized>
}
# [ cfg ( feature = "full" ) ]
pub fn fold_item_use<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemUse) -> ItemUse {
ItemUse {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
vis: _visitor.fold_visibility(_i . vis),
use_token: Token ! [ use ](tokens_helper(_visitor, &(_i . use_token).0)),
leading_colon: (_i . leading_colon).map(|it| { Token ! [ :: ](tokens_helper(_visitor, &(it).0)) }),
- prefix: FoldHelper::lift(_i . prefix, |it| { _visitor.fold_ident(it) }),
tree: _visitor.fold_use_tree(_i . tree),
semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_item_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemVerbatim) -> ItemVerbatim {
ItemVerbatim {
tts: _i . tts,
@@ -2033,25 +2039,24 @@ pub fn fold_lit_bool<V: Fold + ?Sized>(_
value: _i . value,
span: _visitor.fold_span(_i . span),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_lit_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: LitVerbatim) -> LitVerbatim {
LitVerbatim {
token: _i . token,
- span: _visitor.fold_span(_i . span),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn fold_local<V: Fold + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
Local {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
+ pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
ty: (_i . ty).map(|it| { (
Token ! [ : ](tokens_helper(_visitor, &(( it ) . 0).0)),
Box::new(_visitor.fold_type(* ( it ) . 1)),
) }),
init: (_i . init).map(|it| { (
Token ! [ = ](tokens_helper(_visitor, &(( it ) . 0).0)),
Box::new(_visitor.fold_expr(* ( it ) . 1)),
) }),
@@ -2473,16 +2478,17 @@ pub fn fold_stmt<V: Fold + ?Sized>(_visi
Token ! [ ; ](tokens_helper(_visitor, &(_binding_1).0)),
)
}
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_trait_bound<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitBound) -> TraitBound {
TraitBound {
+ paren_token: (_i . paren_token).map(|it| { Paren(tokens_helper(_visitor, &(it).0)) }),
modifier: _visitor.fold_trait_bound_modifier(_i . modifier),
lifetimes: (_i . lifetimes).map(|it| { _visitor.fold_bound_lifetimes(it) }),
path: _visitor.fold_path(_i . path),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_trait_bound_modifier<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitBoundModifier) -> TraitBoundModifier {
match _i {
@@ -2819,48 +2825,70 @@ pub fn fold_un_op<V: Fold + ?Sized>(_vis
}
# [ cfg ( feature = "full" ) ]
pub fn fold_use_glob<V: Fold + ?Sized>(_visitor: &mut V, _i: UseGlob) -> UseGlob {
UseGlob {
star_token: Token ! [ * ](tokens_helper(_visitor, &(_i . star_token).0)),
}
}
# [ cfg ( feature = "full" ) ]
-pub fn fold_use_list<V: Fold + ?Sized>(_visitor: &mut V, _i: UseList) -> UseList {
- UseList {
+pub fn fold_use_group<V: Fold + ?Sized>(_visitor: &mut V, _i: UseGroup) -> UseGroup {
+ UseGroup {
brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
items: FoldHelper::lift(_i . items, |it| { _visitor.fold_use_tree(it) }),
}
}
# [ cfg ( feature = "full" ) ]
+pub fn fold_use_name<V: Fold + ?Sized>(_visitor: &mut V, _i: UseName) -> UseName {
+ UseName {
+ ident: _visitor.fold_ident(_i . ident),
+ }
+}
+# [ cfg ( feature = "full" ) ]
pub fn fold_use_path<V: Fold + ?Sized>(_visitor: &mut V, _i: UsePath) -> UsePath {
UsePath {
ident: _visitor.fold_ident(_i . ident),
- rename: (_i . rename).map(|it| { (
- Token ! [ as ](tokens_helper(_visitor, &(( it ) . 0).0)),
- _visitor.fold_ident(( it ) . 1),
- ) }),
+ colon2_token: Token ! [ :: ](tokens_helper(_visitor, &(_i . colon2_token).0)),
+ tree: Box::new(_visitor.fold_use_tree(* _i . tree)),
+ }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_use_rename<V: Fold + ?Sized>(_visitor: &mut V, _i: UseRename) -> UseRename {
+ UseRename {
+ ident: _visitor.fold_ident(_i . ident),
+ as_token: Token ! [ as ](tokens_helper(_visitor, &(_i . as_token).0)),
+ rename: _visitor.fold_ident(_i . rename),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_use_tree<V: Fold + ?Sized>(_visitor: &mut V, _i: UseTree) -> UseTree {
match _i {
UseTree::Path(_binding_0, ) => {
UseTree::Path (
_visitor.fold_use_path(_binding_0),
)
}
+ UseTree::Name(_binding_0, ) => {
+ UseTree::Name (
+ _visitor.fold_use_name(_binding_0),
+ )
+ }
+ UseTree::Rename(_binding_0, ) => {
+ UseTree::Rename (
+ _visitor.fold_use_rename(_binding_0),
+ )
+ }
UseTree::Glob(_binding_0, ) => {
UseTree::Glob (
_visitor.fold_use_glob(_binding_0),
)
}
- UseTree::List(_binding_0, ) => {
- UseTree::List (
- _visitor.fold_use_list(_binding_0),
+ UseTree::Group(_binding_0, ) => {
+ UseTree::Group (
+ _visitor.fold_use_group(_binding_0),
)
}
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_variant<V: Fold + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant {
Variant {
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
@@ -2870,18 +2898,16 @@ pub fn fold_variant<V: Fold + ?Sized>(_v
Token ! [ = ](tokens_helper(_visitor, &(( it ) . 0).0)),
_visitor.fold_expr(( it ) . 1),
) }),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_vis_crate<V: Fold + ?Sized>(_visitor: &mut V, _i: VisCrate) -> VisCrate {
VisCrate {
- pub_token: Token ! [ pub ](tokens_helper(_visitor, &(_i . pub_token).0)),
- paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
crate_token: Token ! [ crate ](tokens_helper(_visitor, &(_i . crate_token).0)),
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn fold_vis_public<V: Fold + ?Sized>(_visitor: &mut V, _i: VisPublic) -> VisPublic {
VisPublic {
pub_token: Token ! [ pub ](tokens_helper(_visitor, &(_i . pub_token).0)),
}
--- a/third_party/rust/syn/src/gen/visit.rs
+++ b/third_party/rust/syn/src/gen/visit.rs
@@ -69,18 +69,16 @@ fn visit_data_enum(&mut self, i: &'ast D
fn visit_data_struct(&mut self, i: &'ast DataStruct) { visit_data_struct(self, i) }
# [ cfg ( feature = "derive" ) ]
fn visit_data_union(&mut self, i: &'ast DataUnion) { visit_data_union(self, i) }
# [ cfg ( feature = "derive" ) ]
fn visit_derive_input(&mut self, i: &'ast DeriveInput) { visit_derive_input(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr(&mut self, i: &'ast Expr) { visit_expr(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_expr_addr_of(&mut self, i: &'ast ExprAddrOf) { visit_expr_addr_of(self, i) }
-# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_array(&mut self, i: &'ast ExprArray) { visit_expr_array(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_assign(&mut self, i: &'ast ExprAssign) { visit_expr_assign(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_assign_op(&mut self, i: &'ast ExprAssignOp) { visit_expr_assign_op(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_binary(&mut self, i: &'ast ExprBinary) { visit_expr_binary(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -125,16 +123,18 @@ fn visit_expr_match(&mut self, i: &'ast
fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) { visit_expr_method_call(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_paren(&mut self, i: &'ast ExprParen) { visit_expr_paren(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_path(&mut self, i: &'ast ExprPath) { visit_expr_path(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_range(&mut self, i: &'ast ExprRange) { visit_expr_range(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
+fn visit_expr_reference(&mut self, i: &'ast ExprReference) { visit_expr_reference(self, i) }
+# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) { visit_expr_repeat(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_return(&mut self, i: &'ast ExprReturn) { visit_expr_return(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_struct(&mut self, i: &'ast ExprStruct) { visit_expr_struct(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_try(&mut self, i: &'ast ExprTry) { visit_expr_try(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -387,20 +387,24 @@ fn visit_type_trait_object(&mut self, i:
fn visit_type_tuple(&mut self, i: &'ast TypeTuple) { visit_type_tuple(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_type_verbatim(&mut self, i: &'ast TypeVerbatim) { visit_type_verbatim(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_un_op(&mut self, i: &'ast UnOp) { visit_un_op(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_use_glob(&mut self, i: &'ast UseGlob) { visit_use_glob(self, i) }
# [ cfg ( feature = "full" ) ]
-fn visit_use_list(&mut self, i: &'ast UseList) { visit_use_list(self, i) }
+fn visit_use_group(&mut self, i: &'ast UseGroup) { visit_use_group(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_use_name(&mut self, i: &'ast UseName) { visit_use_name(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_use_path(&mut self, i: &'ast UsePath) { visit_use_path(self, i) }
# [ cfg ( feature = "full" ) ]
+fn visit_use_rename(&mut self, i: &'ast UseRename) { visit_use_rename(self, i) }
+# [ cfg ( feature = "full" ) ]
fn visit_use_tree(&mut self, i: &'ast UseTree) { visit_use_tree(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_variant(&mut self, i: &'ast Variant) { visit_variant(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_vis_crate(&mut self, i: &'ast VisCrate) { visit_vis_crate(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_vis_public(&mut self, i: &'ast VisPublic) { visit_vis_public(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -442,22 +446,23 @@ pub fn visit_arg_self_ref<'ast, V: Visit
tokens_helper(_visitor, &(& _i . and_token).0);
if let Some(ref it) = _i . lifetime { _visitor.visit_lifetime(it) };
if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
tokens_helper(_visitor, &(& _i . self_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn visit_arm<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
+ if let Some(ref it) = _i . leading_vert { tokens_helper(_visitor, &(it).0) };
for el in Punctuated::pairs(& _i . pats) { let it = el.value(); _visitor.visit_pat(it) };
if let Some(ref it) = _i . guard {
tokens_helper(_visitor, &(& ( it ) . 0).0);
_visitor.visit_expr(& * ( it ) . 1);
};
- tokens_helper(_visitor, &(& _i . rocket_token).0);
+ tokens_helper(_visitor, &(& _i . fat_arrow_token).0);
_visitor.visit_expr(& * _i . body);
if let Some(ref it) = _i . comma { tokens_helper(_visitor, &(it).0) };
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_attr_style<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AttrStyle) {
match *_i {
AttrStyle::Outer => { }
AttrStyle::Inner(ref _binding_0, ) => {
@@ -728,18 +733,18 @@ pub fn visit_expr<'ast, V: Visit<'ast> +
_visitor.visit_expr_index(_binding_0);
}
Expr::Range(ref _binding_0, ) => {
full!(_visitor.visit_expr_range(_binding_0));
}
Expr::Path(ref _binding_0, ) => {
_visitor.visit_expr_path(_binding_0);
}
- Expr::AddrOf(ref _binding_0, ) => {
- full!(_visitor.visit_expr_addr_of(_binding_0));
+ Expr::Reference(ref _binding_0, ) => {
+ full!(_visitor.visit_expr_reference(_binding_0));
}
Expr::Break(ref _binding_0, ) => {
full!(_visitor.visit_expr_break(_binding_0));
}
Expr::Continue(ref _binding_0, ) => {
full!(_visitor.visit_expr_continue(_binding_0));
}
Expr::Return(ref _binding_0, ) => {
@@ -770,23 +775,16 @@ pub fn visit_expr<'ast, V: Visit<'ast> +
full!(_visitor.visit_expr_yield(_binding_0));
}
Expr::Verbatim(ref _binding_0, ) => {
_visitor.visit_expr_verbatim(_binding_0);
}
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_expr_addr_of<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAddrOf) {
- for it in & _i . attrs { _visitor.visit_attribute(it) };
- tokens_helper(_visitor, &(& _i . and_token).0);
- if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
- _visitor.visit_expr(& * _i . expr);
-}
-# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
tokens_helper(_visitor, &(& _i . bracket_token).0);
for el in Punctuated::pairs(& _i . elems) { let it = el.value(); _visitor.visit_expr(it) };
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_assign<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAssign) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
@@ -845,16 +843,17 @@ pub fn visit_expr_catch<'ast, V: Visit<'
for it in & _i . attrs { _visitor.visit_attribute(it) };
tokens_helper(_visitor, &(& _i . do_token).0);
tokens_helper(_visitor, &(& _i . catch_token).0);
_visitor.visit_block(& _i . block);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_closure<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprClosure) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
+ if let Some(ref it) = _i . movability { tokens_helper(_visitor, &(it).0) };
if let Some(ref it) = _i . capture { tokens_helper(_visitor, &(it).0) };
tokens_helper(_visitor, &(& _i . or1_token).0);
for el in Punctuated::pairs(& _i . inputs) { let it = el.value(); _visitor.visit_fn_arg(it) };
tokens_helper(_visitor, &(& _i . or2_token).0);
_visitor.visit_return_type(& _i . output);
_visitor.visit_expr(& * _i . body);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -897,17 +896,17 @@ pub fn visit_expr_if<'ast, V: Visit<'ast
_visitor.visit_expr(& * ( it ) . 1);
};
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_if_let<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIfLet) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
tokens_helper(_visitor, &(& _i . if_token).0);
tokens_helper(_visitor, &(& _i . let_token).0);
- _visitor.visit_pat(& * _i . pat);
+ for el in Punctuated::pairs(& _i . pats) { let it = el.value(); _visitor.visit_pat(it) };
tokens_helper(_visitor, &(& _i . eq_token).0);
_visitor.visit_expr(& * _i . expr);
_visitor.visit_block(& _i . then_branch);
if let Some(ref it) = _i . else_branch {
tokens_helper(_visitor, &(& ( it ) . 0).0);
_visitor.visit_expr(& * ( it ) . 1);
};
}
@@ -975,16 +974,23 @@ pub fn visit_expr_path<'ast, V: Visit<'a
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRange) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
if let Some(ref it) = _i . from { _visitor.visit_expr(& * * it) };
_visitor.visit_range_limits(& _i . limits);
if let Some(ref it) = _i . to { _visitor.visit_expr(& * * it) };
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
+pub fn visit_expr_reference<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprReference) {
+ for it in & _i . attrs { _visitor.visit_attribute(it) };
+ tokens_helper(_visitor, &(& _i . and_token).0);
+ if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
+ _visitor.visit_expr(& * _i . expr);
+}
+# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_repeat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRepeat) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
tokens_helper(_visitor, &(& _i . bracket_token).0);
_visitor.visit_expr(& * _i . expr);
tokens_helper(_visitor, &(& _i . semi_token).0);
_visitor.visit_expr(& * _i . len);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -1046,17 +1052,17 @@ pub fn visit_expr_while<'ast, V: Visit<'
_visitor.visit_block(& _i . body);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_while_let<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhileLet) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
if let Some(ref it) = _i . label { _visitor.visit_label(it) };
tokens_helper(_visitor, &(& _i . while_token).0);
tokens_helper(_visitor, &(& _i . let_token).0);
- _visitor.visit_pat(& * _i . pat);
+ for el in Punctuated::pairs(& _i . pats) { let it = el.value(); _visitor.visit_pat(it) };
tokens_helper(_visitor, &(& _i . eq_token).0);
_visitor.visit_expr(& * _i . expr);
_visitor.visit_block(& _i . body);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_yield<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprYield) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
tokens_helper(_visitor, &(& _i . yield_token).0);
@@ -1236,17 +1242,16 @@ pub fn visit_generics<'ast, V: Visit<'as
if let Some(ref it) = _i . lt_token { tokens_helper(_visitor, &(it).0) };
for el in Punctuated::pairs(& _i . params) { let it = el.value(); _visitor.visit_generic_param(it) };
if let Some(ref it) = _i . gt_token { tokens_helper(_visitor, &(it).0) };
if let Some(ref it) = _i . where_clause { _visitor.visit_where_clause(it) };
}
pub fn visit_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Ident) {
// Skipped field _i . term;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_impl_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ImplItem) {
match *_i {
ImplItem::Const(ref _binding_0, ) => {
_visitor.visit_impl_item_const(_binding_0);
}
ImplItem::Method(ref _binding_0, ) => {
@@ -1521,33 +1526,31 @@ pub fn visit_item_union<'ast, V: Visit<'
_visitor.visit_fields_named(& _i . fields);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_item_use<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemUse) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
_visitor.visit_visibility(& _i . vis);
tokens_helper(_visitor, &(& _i . use_token).0);
if let Some(ref it) = _i . leading_colon { tokens_helper(_visitor, &(it).0) };
- for el in Punctuated::pairs(& _i . prefix) { let it = el.value(); _visitor.visit_ident(it) };
_visitor.visit_use_tree(& _i . tree);
tokens_helper(_visitor, &(& _i . semi_token).0);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemVerbatim) {
// Skipped field _i . tts;
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn visit_label<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Label) {
_visitor.visit_lifetime(& _i . name);
tokens_helper(_visitor, &(& _i . colon_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lifetime<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lifetime) {
// Skipped field _i . term;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lifetime_def<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LifetimeDef) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
_visitor.visit_lifetime(& _i . lifetime);
if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
for el in Punctuated::pairs(& _i . bounds) { let it = el.value(); _visitor.visit_lifetime(it) };
}
@@ -1583,53 +1586,46 @@ pub fn visit_lit<'ast, V: Visit<'ast> +
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_bool<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitBool) {
// Skipped field _i . value;
_visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_byte<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByte) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_byte_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByteStr) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_char<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitChar) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_float<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitFloat) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_int<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitInt) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitStr) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitVerbatim) {
// Skipped field _i . token;
- _visitor.visit_span(& _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn visit_local<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Local) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
tokens_helper(_visitor, &(& _i . let_token).0);
- _visitor.visit_pat(& * _i . pat);
+ for el in Punctuated::pairs(& _i . pats) { let it = el.value(); _visitor.visit_pat(it) };
if let Some(ref it) = _i . ty {
tokens_helper(_visitor, &(& ( it ) . 0).0);
_visitor.visit_type(& * ( it ) . 1);
};
if let Some(ref it) = _i . init {
tokens_helper(_visitor, &(& ( it ) . 0).0);
_visitor.visit_expr(& * ( it ) . 1);
};
@@ -1934,16 +1930,17 @@ pub fn visit_stmt<'ast, V: Visit<'ast> +
Stmt::Semi(ref _binding_0, ref _binding_1, ) => {
_visitor.visit_expr(_binding_0);
tokens_helper(_visitor, &(_binding_1).0);
}
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_trait_bound<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitBound) {
+ if let Some(ref it) = _i . paren_token { tokens_helper(_visitor, &(it).0) };
_visitor.visit_trait_bound_modifier(& _i . modifier);
if let Some(ref it) = _i . lifetimes { _visitor.visit_bound_lifetimes(it) };
_visitor.visit_path(& _i . path);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_trait_bound_modifier<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitBoundModifier) {
match *_i {
TraitBoundModifier::None => { }
@@ -2183,56 +2180,68 @@ pub fn visit_un_op<'ast, V: Visit<'ast>
}
}
}
# [ cfg ( feature = "full" ) ]
pub fn visit_use_glob<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseGlob) {
tokens_helper(_visitor, &(& _i . star_token).0);
}
# [ cfg ( feature = "full" ) ]
-pub fn visit_use_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseList) {
+pub fn visit_use_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseGroup) {
tokens_helper(_visitor, &(& _i . brace_token).0);
for el in Punctuated::pairs(& _i . items) { let it = el.value(); _visitor.visit_use_tree(it) };
}
# [ cfg ( feature = "full" ) ]
+pub fn visit_use_name<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseName) {
+ _visitor.visit_ident(& _i . ident);
+}
+# [ cfg ( feature = "full" ) ]
pub fn visit_use_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UsePath) {
_visitor.visit_ident(& _i . ident);
- if let Some(ref it) = _i . rename {
- tokens_helper(_visitor, &(& ( it ) . 0).0);
- _visitor.visit_ident(& ( it ) . 1);
- };
+ tokens_helper(_visitor, &(& _i . colon2_token).0);
+ _visitor.visit_use_tree(& * _i . tree);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_use_rename<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseRename) {
+ _visitor.visit_ident(& _i . ident);
+ tokens_helper(_visitor, &(& _i . as_token).0);
+ _visitor.visit_ident(& _i . rename);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_use_tree<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseTree) {
match *_i {
UseTree::Path(ref _binding_0, ) => {
_visitor.visit_use_path(_binding_0);
}
+ UseTree::Name(ref _binding_0, ) => {
+ _visitor.visit_use_name(_binding_0);
+ }
+ UseTree::Rename(ref _binding_0, ) => {
+ _visitor.visit_use_rename(_binding_0);
+ }
UseTree::Glob(ref _binding_0, ) => {
_visitor.visit_use_glob(_binding_0);
}
- UseTree::List(ref _binding_0, ) => {
- _visitor.visit_use_list(_binding_0);
+ UseTree::Group(ref _binding_0, ) => {
+ _visitor.visit_use_group(_binding_0);
}
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_variant<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Variant) {
for it in & _i . attrs { _visitor.visit_attribute(it) };
_visitor.visit_ident(& _i . ident);
_visitor.visit_fields(& _i . fields);
if let Some(ref it) = _i . discriminant {
tokens_helper(_visitor, &(& ( it ) . 0).0);
_visitor.visit_expr(& ( it ) . 1);
};
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_vis_crate<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisCrate) {
- tokens_helper(_visitor, &(& _i . pub_token).0);
- tokens_helper(_visitor, &(& _i . paren_token).0);
tokens_helper(_visitor, &(& _i . crate_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_vis_public<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisPublic) {
tokens_helper(_visitor, &(& _i . pub_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_vis_restricted<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisRestricted) {
--- a/third_party/rust/syn/src/gen/visit_mut.rs
+++ b/third_party/rust/syn/src/gen/visit_mut.rs
@@ -70,18 +70,16 @@ fn visit_data_enum_mut(&mut self, i: &mu
fn visit_data_struct_mut(&mut self, i: &mut DataStruct) { visit_data_struct_mut(self, i) }
# [ cfg ( feature = "derive" ) ]
fn visit_data_union_mut(&mut self, i: &mut DataUnion) { visit_data_union_mut(self, i) }
# [ cfg ( feature = "derive" ) ]
fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) { visit_derive_input_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_mut(&mut self, i: &mut Expr) { visit_expr_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-fn visit_expr_addr_of_mut(&mut self, i: &mut ExprAddrOf) { visit_expr_addr_of_mut(self, i) }
-# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_array_mut(&mut self, i: &mut ExprArray) { visit_expr_array_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) { visit_expr_assign_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) { visit_expr_assign_op_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) { visit_expr_binary_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -126,16 +124,18 @@ fn visit_expr_match_mut(&mut self, i: &m
fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) { visit_expr_method_call_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) { visit_expr_paren_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_path_mut(&mut self, i: &mut ExprPath) { visit_expr_path_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_range_mut(&mut self, i: &mut ExprRange) { visit_expr_range_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
+fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) { visit_expr_reference_mut(self, i) }
+# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) { visit_expr_repeat_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) { visit_expr_return_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) { visit_expr_struct_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_expr_try_mut(&mut self, i: &mut ExprTry) { visit_expr_try_mut(self, i) }
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -388,20 +388,24 @@ fn visit_type_trait_object_mut(&mut self
fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) { visit_type_tuple_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_type_verbatim_mut(&mut self, i: &mut TypeVerbatim) { visit_type_verbatim_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_un_op_mut(&mut self, i: &mut UnOp) { visit_un_op_mut(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_use_glob_mut(&mut self, i: &mut UseGlob) { visit_use_glob_mut(self, i) }
# [ cfg ( feature = "full" ) ]
-fn visit_use_list_mut(&mut self, i: &mut UseList) { visit_use_list_mut(self, i) }
+fn visit_use_group_mut(&mut self, i: &mut UseGroup) { visit_use_group_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
+fn visit_use_name_mut(&mut self, i: &mut UseName) { visit_use_name_mut(self, i) }
# [ cfg ( feature = "full" ) ]
fn visit_use_path_mut(&mut self, i: &mut UsePath) { visit_use_path_mut(self, i) }
# [ cfg ( feature = "full" ) ]
+fn visit_use_rename_mut(&mut self, i: &mut UseRename) { visit_use_rename_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
fn visit_use_tree_mut(&mut self, i: &mut UseTree) { visit_use_tree_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_variant_mut(&mut self, i: &mut Variant) { visit_variant_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) { visit_vis_crate_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
fn visit_vis_public_mut(&mut self, i: &mut VisPublic) { visit_vis_public_mut(self, i) }
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -443,22 +447,23 @@ pub fn visit_arg_self_ref_mut<V: VisitMu
tokens_helper(_visitor, &mut (& mut _i . and_token).0);
if let Some(ref mut it) = _i . lifetime { _visitor.visit_lifetime_mut(it) };
if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
tokens_helper(_visitor, &mut (& mut _i . self_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn visit_arm_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ if let Some(ref mut it) = _i . leading_vert { tokens_helper(_visitor, &mut (it).0) };
for mut el in Punctuated::pairs_mut(& mut _i . pats) { let it = el.value_mut(); _visitor.visit_pat_mut(it) };
if let Some(ref mut it) = _i . guard {
tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
_visitor.visit_expr_mut(& mut * ( it ) . 1);
};
- tokens_helper(_visitor, &mut (& mut _i . rocket_token).0);
+ tokens_helper(_visitor, &mut (& mut _i . fat_arrow_token).0);
_visitor.visit_expr_mut(& mut * _i . body);
if let Some(ref mut it) = _i . comma { tokens_helper(_visitor, &mut (it).0) };
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_attr_style_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) {
match *_i {
AttrStyle::Outer => { }
AttrStyle::Inner(ref mut _binding_0, ) => {
@@ -729,18 +734,18 @@ pub fn visit_expr_mut<V: VisitMut + ?Siz
_visitor.visit_expr_index_mut(_binding_0);
}
Expr::Range(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_range_mut(_binding_0));
}
Expr::Path(ref mut _binding_0, ) => {
_visitor.visit_expr_path_mut(_binding_0);
}
- Expr::AddrOf(ref mut _binding_0, ) => {
- full!(_visitor.visit_expr_addr_of_mut(_binding_0));
+ Expr::Reference(ref mut _binding_0, ) => {
+ full!(_visitor.visit_expr_reference_mut(_binding_0));
}
Expr::Break(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_break_mut(_binding_0));
}
Expr::Continue(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_continue_mut(_binding_0));
}
Expr::Return(ref mut _binding_0, ) => {
@@ -771,23 +776,16 @@ pub fn visit_expr_mut<V: VisitMut + ?Siz
full!(_visitor.visit_expr_yield_mut(_binding_0));
}
Expr::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_expr_verbatim_mut(_binding_0);
}
}
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
-pub fn visit_expr_addr_of_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAddrOf) {
- for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
- tokens_helper(_visitor, &mut (& mut _i . and_token).0);
- if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
- _visitor.visit_expr_mut(& mut * _i . expr);
-}
-# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
for mut el in Punctuated::pairs_mut(& mut _i . elems) { let it = el.value_mut(); _visitor.visit_expr_mut(it) };
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_assign_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
@@ -846,16 +844,17 @@ pub fn visit_expr_catch_mut<V: VisitMut
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . do_token).0);
tokens_helper(_visitor, &mut (& mut _i . catch_token).0);
_visitor.visit_block_mut(& mut _i . block);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_closure_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ if let Some(ref mut it) = _i . movability { tokens_helper(_visitor, &mut (it).0) };
if let Some(ref mut it) = _i . capture { tokens_helper(_visitor, &mut (it).0) };
tokens_helper(_visitor, &mut (& mut _i . or1_token).0);
for mut el in Punctuated::pairs_mut(& mut _i . inputs) { let it = el.value_mut(); _visitor.visit_fn_arg_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . or2_token).0);
_visitor.visit_return_type_mut(& mut _i . output);
_visitor.visit_expr_mut(& mut * _i . body);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -898,17 +897,17 @@ pub fn visit_expr_if_mut<V: VisitMut + ?
_visitor.visit_expr_mut(& mut * ( it ) . 1);
};
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_if_let_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIfLet) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . if_token).0);
tokens_helper(_visitor, &mut (& mut _i . let_token).0);
- _visitor.visit_pat_mut(& mut * _i . pat);
+ for mut el in Punctuated::pairs_mut(& mut _i . pats) { let it = el.value_mut(); _visitor.visit_pat_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . eq_token).0);
_visitor.visit_expr_mut(& mut * _i . expr);
_visitor.visit_block_mut(& mut _i . then_branch);
if let Some(ref mut it) = _i . else_branch {
tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
_visitor.visit_expr_mut(& mut * ( it ) . 1);
};
}
@@ -976,16 +975,23 @@ pub fn visit_expr_path_mut<V: VisitMut +
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
if let Some(ref mut it) = _i . from { _visitor.visit_expr_mut(& mut * * it) };
_visitor.visit_range_limits_mut(& mut _i . limits);
if let Some(ref mut it) = _i . to { _visitor.visit_expr_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
+pub fn visit_expr_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReference) {
+ for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ tokens_helper(_visitor, &mut (& mut _i . and_token).0);
+ if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
+ _visitor.visit_expr_mut(& mut * _i . expr);
+}
+# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_repeat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
_visitor.visit_expr_mut(& mut * _i . expr);
tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
_visitor.visit_expr_mut(& mut * _i . len);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
@@ -1047,17 +1053,17 @@ pub fn visit_expr_while_mut<V: VisitMut
_visitor.visit_block_mut(& mut _i . body);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_while_let_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhileLet) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
if let Some(ref mut it) = _i . label { _visitor.visit_label_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . while_token).0);
tokens_helper(_visitor, &mut (& mut _i . let_token).0);
- _visitor.visit_pat_mut(& mut * _i . pat);
+ for mut el in Punctuated::pairs_mut(& mut _i . pats) { let it = el.value_mut(); _visitor.visit_pat_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . eq_token).0);
_visitor.visit_expr_mut(& mut * _i . expr);
_visitor.visit_block_mut(& mut _i . body);
}
# [ cfg ( feature = "full" ) ] # [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_expr_yield_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . yield_token).0);
@@ -1237,17 +1243,16 @@ pub fn visit_generics_mut<V: VisitMut +
if let Some(ref mut it) = _i . lt_token { tokens_helper(_visitor, &mut (it).0) };
for mut el in Punctuated::pairs_mut(& mut _i . params) { let it = el.value_mut(); _visitor.visit_generic_param_mut(it) };
if let Some(ref mut it) = _i . gt_token { tokens_helper(_visitor, &mut (it).0) };
if let Some(ref mut it) = _i . where_clause { _visitor.visit_where_clause_mut(it) };
}
pub fn visit_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ident) {
// Skipped field _i . term;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_impl_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) {
match *_i {
ImplItem::Const(ref mut _binding_0, ) => {
_visitor.visit_impl_item_const_mut(_binding_0);
}
ImplItem::Method(ref mut _binding_0, ) => {
@@ -1522,33 +1527,31 @@ pub fn visit_item_union_mut<V: VisitMut
_visitor.visit_fields_named_mut(& mut _i . fields);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_item_use_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUse) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
_visitor.visit_visibility_mut(& mut _i . vis);
tokens_helper(_visitor, &mut (& mut _i . use_token).0);
if let Some(ref mut it) = _i . leading_colon { tokens_helper(_visitor, &mut (it).0) };
- for mut el in Punctuated::pairs_mut(& mut _i . prefix) { let it = el.value_mut(); _visitor.visit_ident_mut(it) };
_visitor.visit_use_tree_mut(& mut _i . tree);
tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_item_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemVerbatim) {
// Skipped field _i . tts;
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn visit_label_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Label) {
_visitor.visit_lifetime_mut(& mut _i . name);
tokens_helper(_visitor, &mut (& mut _i . colon_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lifetime_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lifetime) {
// Skipped field _i . term;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lifetime_def_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LifetimeDef) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
_visitor.visit_lifetime_mut(& mut _i . lifetime);
if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
for mut el in Punctuated::pairs_mut(& mut _i . bounds) { let it = el.value_mut(); _visitor.visit_lifetime_mut(it) };
}
@@ -1584,53 +1587,46 @@ pub fn visit_lit_mut<V: VisitMut + ?Size
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_bool_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitBool) {
// Skipped field _i . value;
_visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_byte_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByte) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_byte_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByteStr) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_char_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitChar) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_float_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitFloat) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_int_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitInt) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitStr) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_lit_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitVerbatim) {
// Skipped field _i . token;
- _visitor.visit_span_mut(& mut _i . span);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ] # [ cfg ( feature = "full" ) ]
pub fn visit_local_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Local) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . let_token).0);
- _visitor.visit_pat_mut(& mut * _i . pat);
+ for mut el in Punctuated::pairs_mut(& mut _i . pats) { let it = el.value_mut(); _visitor.visit_pat_mut(it) };
if let Some(ref mut it) = _i . ty {
tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
_visitor.visit_type_mut(& mut * ( it ) . 1);
};
if let Some(ref mut it) = _i . init {
tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
_visitor.visit_expr_mut(& mut * ( it ) . 1);
};
@@ -1935,16 +1931,17 @@ pub fn visit_stmt_mut<V: VisitMut + ?Siz
Stmt::Semi(ref mut _binding_0, ref mut _binding_1, ) => {
_visitor.visit_expr_mut(_binding_0);
tokens_helper(_visitor, &mut (_binding_1).0);
}
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_trait_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBound) {
+ if let Some(ref mut it) = _i . paren_token { tokens_helper(_visitor, &mut (it).0) };
_visitor.visit_trait_bound_modifier_mut(& mut _i . modifier);
if let Some(ref mut it) = _i . lifetimes { _visitor.visit_bound_lifetimes_mut(it) };
_visitor.visit_path_mut(& mut _i . path);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_trait_bound_modifier_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBoundModifier) {
match *_i {
TraitBoundModifier::None => { }
@@ -2184,56 +2181,68 @@ pub fn visit_un_op_mut<V: VisitMut + ?Si
}
}
}
# [ cfg ( feature = "full" ) ]
pub fn visit_use_glob_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseGlob) {
tokens_helper(_visitor, &mut (& mut _i . star_token).0);
}
# [ cfg ( feature = "full" ) ]
-pub fn visit_use_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseList) {
+pub fn visit_use_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseGroup) {
tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
for mut el in Punctuated::pairs_mut(& mut _i . items) { let it = el.value_mut(); _visitor.visit_use_tree_mut(it) };
}
# [ cfg ( feature = "full" ) ]
+pub fn visit_use_name_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseName) {
+ _visitor.visit_ident_mut(& mut _i . ident);
+}
+# [ cfg ( feature = "full" ) ]
pub fn visit_use_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UsePath) {
_visitor.visit_ident_mut(& mut _i . ident);
- if let Some(ref mut it) = _i . rename {
- tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
- _visitor.visit_ident_mut(& mut ( it ) . 1);
- };
+ tokens_helper(_visitor, &mut (& mut _i . colon2_token).0);
+ _visitor.visit_use_tree_mut(& mut * _i . tree);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_use_rename_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseRename) {
+ _visitor.visit_ident_mut(& mut _i . ident);
+ tokens_helper(_visitor, &mut (& mut _i . as_token).0);
+ _visitor.visit_ident_mut(& mut _i . rename);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_use_tree_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseTree) {
match *_i {
UseTree::Path(ref mut _binding_0, ) => {
_visitor.visit_use_path_mut(_binding_0);
}
+ UseTree::Name(ref mut _binding_0, ) => {
+ _visitor.visit_use_name_mut(_binding_0);
+ }
+ UseTree::Rename(ref mut _binding_0, ) => {
+ _visitor.visit_use_rename_mut(_binding_0);
+ }
UseTree::Glob(ref mut _binding_0, ) => {
_visitor.visit_use_glob_mut(_binding_0);
}
- UseTree::List(ref mut _binding_0, ) => {
- _visitor.visit_use_list_mut(_binding_0);
+ UseTree::Group(ref mut _binding_0, ) => {
+ _visitor.visit_use_group_mut(_binding_0);
}
}
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_variant_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Variant) {
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
_visitor.visit_ident_mut(& mut _i . ident);
_visitor.visit_fields_mut(& mut _i . fields);
if let Some(ref mut it) = _i . discriminant {
tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
_visitor.visit_expr_mut(& mut ( it ) . 1);
};
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_vis_crate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisCrate) {
- tokens_helper(_visitor, &mut (& mut _i . pub_token).0);
- tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
tokens_helper(_visitor, &mut (& mut _i . crate_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_vis_public_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisPublic) {
tokens_helper(_visitor, &mut (& mut _i . pub_token).0);
}
# [ cfg ( any ( feature = "full" , feature = "derive" ) ) ]
pub fn visit_vis_restricted_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisRestricted) {
--- a/third_party/rust/syn/src/generics.rs
+++ b/third_party/rust/syn/src/generics.rs
@@ -138,19 +138,34 @@ impl Generics {
/// style="padding-right:0;">Iterator<Item = &mut </code><a
/// href="struct.ConstParam.html"><code
/// style="padding-left:0;padding-right:0;">ConstParam</code></a><code
/// style="padding-left:0;">></code>
/// over the constant parameters in `self.params`.
pub fn const_params_mut(&mut self) -> ConstParamsMut {
ConstParamsMut(self.params.iter_mut())
}
+
+ /// Initializes an empty `where`-clause if there is not one present already.
+ pub fn make_where_clause(&mut self) -> &mut WhereClause {
+ // This is Option::get_or_insert_with in Rust 1.20.
+ if self.where_clause.is_none() {
+ self.where_clause = Some(WhereClause {
+ where_token: Default::default(),
+ predicates: Punctuated::new(),
+ });
+ }
+ match self.where_clause {
+ Some(ref mut where_clause) => where_clause,
+ None => unreachable!(),
+ }
+ }
}
-pub struct TypeParams<'a>(Iter<'a, GenericParam, Token![,]>);
+pub struct TypeParams<'a>(Iter<'a, GenericParam>);
impl<'a> Iterator for TypeParams<'a> {
type Item = &'a TypeParam;
fn next(&mut self) -> Option<Self::Item> {
// FIXME: Remove this when ? on Option is stable
let next = match self.0.next() {
Some(item) => item,
@@ -159,17 +174,17 @@ impl<'a> Iterator for TypeParams<'a> {
if let GenericParam::Type(ref type_param) = *next {
Some(type_param)
} else {
self.next()
}
}
}
-pub struct TypeParamsMut<'a>(IterMut<'a, GenericParam, Token![,]>);
+pub struct TypeParamsMut<'a>(IterMut<'a, GenericParam>);
impl<'a> Iterator for TypeParamsMut<'a> {
type Item = &'a mut TypeParam;
fn next(&mut self) -> Option<Self::Item> {
// FIXME: Remove this when ? on Option is stable
let next = match self.0.next() {
Some(item) => item,
@@ -178,17 +193,17 @@ impl<'a> Iterator for TypeParamsMut<'a>
if let GenericParam::Type(ref mut type_param) = *next {
Some(type_param)
} else {
self.next()
}
}
}
-pub struct Lifetimes<'a>(Iter<'a, GenericParam, Token![,]>);
+pub struct Lifetimes<'a>(Iter<'a, GenericParam>);
impl<'a> Iterator for Lifetimes<'a> {
type Item = &'a LifetimeDef;
fn next(&mut self) -> Option<Self::Item> {
// FIXME: Remove this when ? on Option is stable
let next = match self.0.next() {
Some(item) => item,
@@ -197,17 +212,17 @@ impl<'a> Iterator for Lifetimes<'a> {
if let GenericParam::Lifetime(ref lifetime) = *next {
Some(lifetime)
} else {
self.next()
}
}
}
-pub struct LifetimesMut<'a>(IterMut<'a, GenericParam, Token![,]>);
+pub struct LifetimesMut<'a>(IterMut<'a, GenericParam>);
impl<'a> Iterator for LifetimesMut<'a> {
type Item = &'a mut LifetimeDef;
fn next(&mut self) -> Option<Self::Item> {
// FIXME: Remove this when ? on Option is stable
let next = match self.0.next() {
Some(item) => item,
@@ -216,17 +231,17 @@ impl<'a> Iterator for LifetimesMut<'a> {
if let GenericParam::Lifetime(ref mut lifetime) = *next {
Some(lifetime)
} else {
self.next()
}
}
}
-pub struct ConstParams<'a>(Iter<'a, GenericParam, Token![,]>);
+pub struct ConstParams<'a>(Iter<'a, GenericParam>);
impl<'a> Iterator for ConstParams<'a> {
type Item = &'a ConstParam;
fn next(&mut self) -> Option<Self::Item> {
// FIXME: Remove this when ? on Option is stable
let next = match self.0.next() {
Some(item) => item,
@@ -235,17 +250,17 @@ impl<'a> Iterator for ConstParams<'a> {
if let GenericParam::Const(ref const_param) = *next {
Some(const_param)
} else {
self.next()
}
}
}
-pub struct ConstParamsMut<'a>(IterMut<'a, GenericParam, Token![,]>);
+pub struct ConstParamsMut<'a>(IterMut<'a, GenericParam>);
impl<'a> Iterator for ConstParamsMut<'a> {
type Item = &'a mut ConstParam;
fn next(&mut self) -> Option<Self::Item> {
// FIXME: Remove this when ? on Option is stable
let next = match self.0.next() {
Some(item) => item,
@@ -380,16 +395,17 @@ ast_enum_of_structs! {
}
ast_struct! {
/// A trait used as a bound on a type parameter.
///
/// *This type is available if Syn is built with the `"derive"` or `"full"`
/// feature.*
pub struct TraitBound {
+ pub paren_token: Option<token::Paren>,
pub modifier: TraitBoundModifier,
/// The `for<'a>` in `for<'a> Foo<&'a T>`
pub lifetimes: Option<BoundLifetimes>,
/// The `Foo<&'a T>` in `for<'a> Foo<&'a T>`
pub path: Path,
}
}
@@ -594,17 +610,20 @@ pub mod parsing {
}
impl Synom for TypeParamBound {
named!(parse -> Self, alt!(
syn!(Lifetime) => { TypeParamBound::Lifetime }
|
syn!(TraitBound) => { TypeParamBound::Trait }
|
- parens!(syn!(TraitBound)) => { |bound| TypeParamBound::Trait(bound.1) }
+ parens!(syn!(TraitBound)) => {|(parens, mut bound)| {
+ bound.paren_token = Some(parens);
+ TypeParamBound::Trait(bound)
+ }}
));
fn description() -> Option<&'static str> {
Some("type parameter bound")
}
}
impl Synom for TraitBound {
@@ -617,16 +636,17 @@ pub mod parsing {
syn!(ParenthesizedGenericArguments)
)) >>
({
if let Some(parenthesized) = parenthesized {
let parenthesized = PathArguments::Parenthesized(parenthesized);
path.segments.last_mut().unwrap().value_mut().arguments = parenthesized;
}
TraitBound {
+ paren_token: None,
modifier: modifier,
lifetimes: lifetimes,
path: path,
}
})
));
fn description() -> Option<&'static str> {
@@ -914,19 +934,25 @@ mod printing {
TokensOrDefault(&self.eq_token).to_tokens(tokens);
self.default.to_tokens(tokens);
}
}
}
impl ToTokens for TraitBound {
fn to_tokens(&self, tokens: &mut Tokens) {
- self.modifier.to_tokens(tokens);
- self.lifetimes.to_tokens(tokens);
- self.path.to_tokens(tokens);
+ let to_tokens = |tokens: &mut Tokens| {
+ self.modifier.to_tokens(tokens);
+ self.lifetimes.to_tokens(tokens);
+ self.path.to_tokens(tokens);
+ };
+ match self.paren_token {
+ Some(ref paren) => paren.surround(tokens, to_tokens),
+ None => to_tokens(tokens),
+ }
}
}
impl ToTokens for TraitBoundModifier {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
TraitBoundModifier::None => {}
TraitBoundModifier::Maybe(ref t) => t.to_tokens(tokens),
@@ -945,18 +971,20 @@ mod printing {
TokensOrDefault(&self.eq_token).to_tokens(tokens);
self.default.to_tokens(tokens);
}
}
}
impl ToTokens for WhereClause {
fn to_tokens(&self, tokens: &mut Tokens) {
- self.where_token.to_tokens(tokens);
- self.predicates.to_tokens(tokens);
+ if !self.predicates.is_empty() {
+ self.where_token.to_tokens(tokens);
+ self.predicates.to_tokens(tokens);
+ }
}
}
impl ToTokens for PredicateType {
fn to_tokens(&self, tokens: &mut Tokens) {
self.lifetimes.to_tokens(tokens);
self.bounded_ty.to_tokens(tokens);
self.colon_token.to_tokens(tokens);
--- a/third_party/rust/syn/src/ident.rs
+++ b/third_party/rust/syn/src/ident.rs
@@ -94,17 +94,16 @@ use proc_macro2::Span;
/// let ident_string = ident.to_string();
/// give_away(ident_string);
///
/// fn give_away(s: String) { /* ... */ }
/// ```
#[derive(Copy, Clone, Debug)]
pub struct Ident {
term: Term,
- pub span: Span,
}
impl Ident {
/// Creates an ident with the given string representation.
///
/// # Panics
///
/// Panics if the input string is neither a keyword nor a legal variable
@@ -140,25 +139,32 @@ impl Ident {
true
}
if !xid_ok(s) {
panic!("{:?} is not a valid ident", s);
}
Ident {
- term: Term::intern(s),
- span: span,
+ term: Term::new(s, span),
}
}
+
+ pub fn span(&self) -> Span {
+ self.term.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.term.set_span(span);
+ }
}
impl<'a> From<&'a str> for Ident {
fn from(s: &str) -> Self {
- Ident::new(s, Span::def_site())
+ Ident::new(s, Span::call_site())
}
}
impl From<Token![self]> for Ident {
fn from(tok: Token![self]) -> Self {
Ident::new("self", tok.0)
}
}
@@ -178,23 +184,23 @@ impl From<Token![super]> for Ident {
impl From<Token![crate]> for Ident {
fn from(tok: Token![crate]) -> Self {
Ident::new("crate", tok.0)
}
}
impl<'a> From<Cow<'a, str>> for Ident {
fn from(s: Cow<'a, str>) -> Self {
- Ident::new(&s, Span::def_site())
+ Ident::new(&s, Span::call_site())
}
}
impl From<String> for Ident {
fn from(s: String) -> Self {
- Ident::new(&s, Span::def_site())
+ Ident::new(&s, Span::call_site())
}
}
impl AsRef<str> for Ident {
fn as_ref(&self) -> &str {
self.term.as_str()
}
}
@@ -239,17 +245,17 @@ pub mod parsing {
use super::*;
use synom::Synom;
use buffer::Cursor;
use parse_error;
use synom::PResult;
impl Synom for Ident {
fn parse(input: Cursor) -> PResult<Self> {
- let (span, term, rest) = match input.term() {
+ let (term, rest) = match input.term() {
Some(term) => term,
_ => return parse_error(),
};
if term.as_str().starts_with('\'') {
return parse_error();
}
match term.as_str() {
// From https://doc.rust-lang.org/grammar.html#keywords
@@ -260,36 +266,31 @@ pub mod parsing {
| "pure" | "ref" | "return" | "Self" | "self" | "sizeof" | "static" | "struct"
| "super" | "trait" | "true" | "type" | "typeof" | "unsafe" | "unsized" | "use"
| "virtual" | "where" | "while" | "yield" => return parse_error(),
_ => {}
}
Ok((
Ident {
- span: span,
term: term,
},
rest,
))
}
fn description() -> Option<&'static str> {
Some("identifier")
}
}
}
#[cfg(feature = "printing")]
mod printing {
use super::*;
use quote::{ToTokens, Tokens};
- use proc_macro2::{TokenNode, TokenTree};
impl ToTokens for Ident {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Term(self.term),
- })
+ tokens.append(self.term);
}
}
}
--- a/third_party/rust/syn/src/item.rs
+++ b/third_party/rust/syn/src/item.rs
@@ -44,17 +44,16 @@ ast_enum_of_structs! {
/// A use declaration: `use std::collections::HashMap`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub Use(ItemUse {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub use_token: Token![use],
pub leading_colon: Option<Token![::]>,
- pub prefix: Punctuated<Ident, Token![::]>,
pub tree: UseTree,
pub semi_token: Token![;],
}),
/// A static item: `static BIKE: Shed = Shed(42)`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub Static(ItemStatic {
@@ -333,35 +332,52 @@ ast_enum_of_structs! {
/// *This type is available if Syn is built with the `"full"` feature.*
///
/// # Syntax tree enum
///
/// This type is a [syntax tree enum].
///
/// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
pub enum UseTree {
- /// An identifier imported by a `use` item: `Type` or `Type as Renamed`.
+ /// A path prefix of imports in a `use` item: `std::...`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub Path(UsePath {
pub ident: Ident,
- pub rename: Option<(Token![as], Ident)>,
+ pub colon2_token: Token![::],
+ pub tree: Box<UseTree>,
+ }),
+
+ /// An identifier imported by a `use` item: `HashMap`.
+ ///
+ /// *This type is available if Syn is built with the `"full"` feature.*
+ pub Name(UseName {
+ pub ident: Ident,
+ }),
+
+ /// An renamed identifier imported by a `use` item: `HashMap as Map`.
+ ///
+ /// *This type is available if Syn is built with the `"full"` feature.*
+ pub Rename(UseRename {
+ pub ident: Ident,
+ pub as_token: Token![as],
+ pub rename: Ident,
}),
/// A glob import in a `use` item: `*`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
pub Glob(UseGlob {
pub star_token: Token![*],
}),
- /// A braced list of imports in a `use` item: `{A, B, C}`.
+ /// A braced group of imports in a `use` item: `{A, B, C}`.
///
/// *This type is available if Syn is built with the `"full"` feature.*
- pub List(UseList {
+ pub Group(UseGroup {
pub brace_token: token::Brace,
pub items: Punctuated<UseTree, Token![,]>,
}),
}
}
ast_enum_of_structs! {
/// An item within an `extern` block.
@@ -788,89 +804,89 @@ pub mod parsing {
})
));
impl_synom!(ItemUse "use item" do_parse!(
attrs: many0!(Attribute::parse_outer) >>
vis: syn!(Visibility) >>
use_: keyword!(use) >>
leading_colon: option!(punct!(::)) >>
- mut prefix: call!(Punctuated::parse_terminated_with, use_prefix) >>
- tree: switch!(value!(prefix.empty_or_trailing()),
- true => syn!(UseTree)
- |
- false => alt!(
- tuple!(keyword!(as), syn!(Ident)) => {
- |rename| UseTree::Path(UsePath {
- ident: prefix.pop().unwrap().into_value(),
- rename: Some(rename),
- })
- }
- |
- epsilon!() => {
- |_| UseTree::Path(UsePath {
- ident: prefix.pop().unwrap().into_value(),
- rename: None,
- })
- }
- )
- ) >>
+ tree: syn!(UseTree) >>
semi: punct!(;) >>
(ItemUse {
attrs: attrs,
vis: vis,
use_token: use_,
leading_colon: leading_colon,
- prefix: prefix,
tree: tree,
semi_token: semi,
})
));
- named!(use_prefix -> Ident, alt!(
+ named!(use_element -> Ident, alt!(
syn!(Ident)
|
keyword!(self) => { Into::into }
|
keyword!(super) => { Into::into }
|
keyword!(crate) => { Into::into }
));
impl_synom!(UseTree "use tree" alt!(
+ syn!(UseRename) => { UseTree::Rename }
+ |
syn!(UsePath) => { UseTree::Path }
|
+ syn!(UseName) => { UseTree::Name }
+ |
syn!(UseGlob) => { UseTree::Glob }
|
- syn!(UseList) => { UseTree::List }
+ syn!(UseGroup) => { UseTree::Group }
));
impl_synom!(UsePath "use path" do_parse!(
- ident: alt!(
- syn!(Ident)
- |
- keyword!(self) => { Into::into }
- ) >>
- rename: option!(tuple!(keyword!(as), syn!(Ident))) >>
+ ident: call!(use_element) >>
+ colon2_token: punct!(::) >>
+ tree: syn!(UseTree) >>
(UsePath {
ident: ident,
+ colon2_token: colon2_token,
+ tree: Box::new(tree),
+ })
+ ));
+
+ impl_synom!(UseName "use name" do_parse!(
+ ident: call!(use_element) >>
+ (UseName {
+ ident: ident,
+ })
+ ));
+
+ impl_synom!(UseRename "use rename" do_parse!(
+ ident: call!(use_element) >>
+ as_token: keyword!(as) >>
+ rename: syn!(Ident) >>
+ (UseRename {
+ ident: ident,
+ as_token: as_token,
rename: rename,
})
));
impl_synom!(UseGlob "use glob" do_parse!(
star: punct!(*) >>
(UseGlob {
star_token: star,
})
));
- impl_synom!(UseList "use list" do_parse!(
+ impl_synom!(UseGroup "use group" do_parse!(
list: braces!(Punctuated::parse_terminated) >>
- (UseList {
+ (UseGroup {
brace_token: list.0,
items: list.1,
})
));
impl_synom!(ItemStatic "static item" do_parse!(
attrs: many0!(Attribute::parse_outer) >>
vis: syn!(Visibility) >>
@@ -1344,47 +1360,54 @@ pub mod parsing {
(TraitItemMacro {
attrs: attrs,
mac: mac,
semi_token: semi,
})
));
impl_synom!(ItemImpl "impl item" do_parse!(
- attrs: many0!(Attribute::parse_outer) >>
+ outer_attrs: many0!(Attribute::parse_outer) >>
defaultness: option!(keyword!(default)) >>
unsafety: option!(keyword!(unsafe)) >>
impl_: keyword!(impl) >>
generics: syn!(Generics) >>
polarity_path: alt!(
do_parse!(
polarity: option!(punct!(!)) >>
path: syn!(Path) >>
for_: keyword!(for) >>
(Some((polarity, path, for_)))
)
|
epsilon!() => { |_| None }
) >>
self_ty: syn!(Type) >>
where_clause: option!(syn!(WhereClause)) >>
- body: braces!(many0!(ImplItem::parse)) >>
+ inner: braces!(tuple!(
+ many0!(Attribute::parse_inner),
+ many0!(ImplItem::parse)
+ )) >>
(ItemImpl {
- attrs: attrs,
+ attrs: {
+ let mut attrs = outer_attrs;
+ attrs.extend((inner.1).0);
+ attrs
+ },
defaultness: defaultness,
unsafety: unsafety,
impl_token: impl_,
generics: Generics {
where_clause: where_clause,
.. generics
},
trait_: polarity_path,
self_ty: Box::new(self_ty),
- brace_token: body.0,
- items: body.1,
+ brace_token: inner.0,
+ items: (inner.1).1,
})
));
impl_synom!(ImplItem "item in impl block" alt!(
syn!(ImplItemConst) => { ImplItem::Const }
|
syn!(ImplItemMethod) => { ImplItem::Method }
|
@@ -1531,17 +1554,16 @@ mod printing {
}
impl ToTokens for ItemUse {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
self.vis.to_tokens(tokens);
self.use_token.to_tokens(tokens);
self.leading_colon.to_tokens(tokens);
- self.prefix.to_tokens(tokens);
self.tree.to_tokens(tokens);
self.semi_token.to_tokens(tokens);
}
}
impl ToTokens for ItemStatic {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
@@ -1708,16 +1730,17 @@ mod printing {
if let Some((ref polarity, ref path, ref for_token)) = self.trait_ {
polarity.to_tokens(tokens);
path.to_tokens(tokens);
for_token.to_tokens(tokens);
}
self.self_ty.to_tokens(tokens);
self.generics.where_clause.to_tokens(tokens);
self.brace_token.surround(tokens, |tokens| {
+ tokens.append_all(self.attrs.inner());
tokens.append_all(&self.items);
});
}
}
impl ToTokens for ItemMacro {
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append_all(self.attrs.outer());
@@ -1758,30 +1781,42 @@ mod printing {
fn to_tokens(&self, tokens: &mut Tokens) {
self.tts.to_tokens(tokens);
}
}
impl ToTokens for UsePath {
fn to_tokens(&self, tokens: &mut Tokens) {
self.ident.to_tokens(tokens);
- if let Some((ref as_token, ref rename)) = self.rename {
- as_token.to_tokens(tokens);
- rename.to_tokens(tokens);
- }
+ self.colon2_token.to_tokens(tokens);
+ self.tree.to_tokens(tokens);
+ }
+ }
+
+ impl ToTokens for UseName {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.ident.to_tokens(tokens);
+ }
+ }
+
+ impl ToTokens for UseRename {
+ fn to_tokens(&self, tokens: &mut Tokens) {
+ self.ident.to_tokens(tokens);
+ self.as_token.to_tokens(tokens);
+ self.rename.to_tokens(tokens);
}
}
impl ToTokens for UseGlob {
fn to_tokens(&self, tokens: &mut Tokens) {
self.star_token.to_tokens(tokens);
}
}
- impl ToTokens for UseList {
+ impl ToTokens for UseGroup {
fn to_tokens(&self, tokens: &mut Tokens) {
self.brace_token.surround(tokens, |tokens| {
self.items.to_tokens(tokens);
});
}
}
impl ToTokens for TraitItemConst {
--- a/third_party/rust/syn/src/lib.rs
+++ b/third_party/rust/syn/src/lib.rs
@@ -63,18 +63,18 @@
//! get to execute arbitrary Rust code to figure out what to do with those
//! tokens, then hand some tokens back to the compiler to compile into the
//! user's crate.
//!
//! [`TokenStream`]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
//!
//! ```toml
//! [dependencies]
-//! syn = "0.12"
-//! quote = "0.4"
+//! syn = "0.13"
+//! quote = "0.5"
//!
//! [lib]
//! proc-macro = true
//! ```
//!
//! ```rust
//! extern crate proc_macro;
//! extern crate syn;
@@ -251,22 +251,23 @@
//! tree.
//! - **`fold`** — Trait for transforming an owned syntax tree.
//! - **`clone-impls`** *(enabled by default)* — Clone impls for all syntax tree
//! types.
//! - **`extra-traits`** — Debug, Eq, PartialEq, Hash impls for all syntax tree
//! types.
// Syn types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/syn/0.12.12")]
+#![doc(html_root_url = "https://docs.rs/syn/0.13.1")]
#![cfg_attr(feature = "cargo-clippy",
allow(const_static_lifetime, doc_markdown, large_enum_variant, match_bool,
- redundant_closure, needless_pass_by_value))]
+ redundant_closure, needless_pass_by_value, redundant_field_names))]
extern crate proc_macro2;
+#[cfg(feature = "proc-macro")]
extern crate proc_macro;
extern crate unicode_xid;
#[cfg(feature = "printing")]
extern crate quote;
#[cfg(feature = "parsing")]
#[macro_use]
@@ -288,17 +289,17 @@ pub use attr::{AttrStyle, Attribute, Met
mod data;
#[cfg(any(feature = "full", feature = "derive"))]
pub use data::{Field, Fields, FieldsNamed, FieldsUnnamed, Variant, VisCrate, VisPublic,
VisRestricted, Visibility};
#[cfg(any(feature = "full", feature = "derive"))]
mod expr;
#[cfg(any(feature = "full", feature = "derive"))]
-pub use expr::{Expr, ExprAddrOf, ExprArray, ExprAssign, ExprAssignOp, ExprBinary, ExprBlock,
+pub use expr::{Expr, ExprReference, ExprArray, ExprAssign, ExprAssignOp, ExprBinary, ExprBlock,
ExprBox, ExprBreak, ExprCall, ExprCast, ExprCatch, ExprClosure, ExprContinue,
ExprField, ExprForLoop, ExprGroup, ExprIf, ExprIfLet, ExprInPlace, ExprIndex,
ExprLit, ExprLoop, ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath,
ExprRange, ExprRepeat, ExprReturn, ExprStruct, ExprTry, ExprTuple, ExprType,
ExprUnary, ExprUnsafe, ExprVerbatim, ExprWhile, ExprWhileLet, ExprYield, Index,
Member};
#[cfg(feature = "full")]
@@ -323,18 +324,18 @@ pub use ident::Ident;
mod item;
#[cfg(feature = "full")]
pub use item::{ArgCaptured, ArgSelf, ArgSelfRef, FnArg, FnDecl, ForeignItem, ForeignItemFn,
ForeignItemStatic, ForeignItemType, ForeignItemVerbatim, ImplItem, ImplItemConst,
ImplItemMacro, ImplItemMethod, ImplItemType, ImplItemVerbatim, Item, ItemConst,
ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMacro2,
ItemMod, ItemStatic, ItemStruct, ItemTrait, ItemType, ItemUnion, ItemUse,
ItemVerbatim, MethodSig, TraitItem, TraitItemConst, TraitItemMacro,
- TraitItemMethod, TraitItemType, TraitItemVerbatim, UseGlob, UseList, UsePath,
- UseTree};
+ TraitItemMethod, TraitItemType, TraitItemVerbatim, UseGlob, UseGroup, UseName,
+ UsePath, UseRename, UseTree};
#[cfg(feature = "full")]
mod file;
#[cfg(feature = "full")]
pub use file::File;
#[cfg(any(feature = "full", feature = "derive"))]
mod lifetime;
@@ -567,17 +568,17 @@ pub use error::parse_error;
/// };
///
/// // Convert into a token stream and return it
/// expanded.into()
/// }
/// #
/// # fn main() {}
/// ```
-#[cfg(feature = "parsing")]
+#[cfg(all(feature = "parsing", feature = "proc-macro"))]
pub fn parse<T>(tokens: proc_macro::TokenStream) -> Result<T, ParseError>
where
T: Synom,
{
parse2(tokens.into())
}
/// Parse a proc-macro2 token stream into the chosen syntax tree node.
--- a/third_party/rust/syn/src/lifetime.rs
+++ b/third_party/rust/syn/src/lifetime.rs
@@ -14,51 +14,43 @@ use proc_macro2::{Span, Term};
use unicode_xid::UnicodeXID;
/// A Rust lifetime: `'a`.
///
/// Lifetime names must conform to the following rules:
///
/// - Must start with an apostrophe.
/// - Must not consist of just an apostrophe: `'`.
-/// - Must not consist of apostrophe + underscore: `'_`.
/// - Character after the apostrophe must be `_` or a Unicode code point with
/// the XID_Start property.
/// - All following characters must be Unicode code points with the XID_Continue
/// property.
///
/// *This type is available if Syn is built with the `"derive"` or `"full"`
/// feature.*
#[cfg_attr(feature = "extra-traits", derive(Debug))]
#[derive(Copy, Clone)]
pub struct Lifetime {
term: Term,
- pub span: Span,
}
impl Lifetime {
- pub fn new(term: Term, span: Span) -> Self {
- let s = term.as_str();
-
+ pub fn new(s: &str, span: Span) -> Self {
if !s.starts_with('\'') {
panic!(
"lifetime name must start with apostrophe as in \"'a\", \
got {:?}",
s
);
}
if s == "'" {
panic!("lifetime name must not be empty");
}
- if s == "'_" {
- panic!("\"'_\" is not a valid lifetime name");
- }
-
fn xid_ok(s: &str) -> bool {
let mut chars = s.chars();
let first = chars.next().unwrap();
if !(UnicodeXID::is_xid_start(first) || first == '_') {
return false;
}
for ch in chars {
if !UnicodeXID::is_xid_continue(ch) {
@@ -68,20 +60,27 @@ impl Lifetime {
true
}
if !xid_ok(&s[1..]) {
panic!("{:?} is not a valid lifetime name", s);
}
Lifetime {
- term: term,
- span: span,
+ term: Term::new(s, span),
}
}
+
+ pub fn span(&self) -> Span {
+ self.term.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.term.set_span(span);
+ }
}
impl Display for Lifetime {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
self.term.as_str().fmt(formatter)
}
}
@@ -116,46 +115,41 @@ pub mod parsing {
use super::*;
use synom::Synom;
use buffer::Cursor;
use parse_error;
use synom::PResult;
impl Synom for Lifetime {
fn parse(input: Cursor) -> PResult<Self> {
- let (span, term, rest) = match input.term() {
+ let (term, rest) = match input.term() {
Some(term) => term,
_ => return parse_error(),
};
if !term.as_str().starts_with('\'') {
return parse_error();
}
Ok((
Lifetime {
term: term,
- span: span,
},
rest,
))
}
fn description() -> Option<&'static str> {
Some("lifetime")
}
}
}
#[cfg(feature = "printing")]
mod printing {
use super::*;
use quote::{ToTokens, Tokens};
- use proc_macro2::{TokenNode, TokenTree};
impl ToTokens for Lifetime {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Term(self.term),
- })
+ self.term.to_tokens(tokens);
}
}
}
--- a/third_party/rust/syn/src/lit.rs
+++ b/third_party/rust/syn/src/lit.rs
@@ -1,28 +1,28 @@
// Copyright 2018 Syn Developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use proc_macro2::{Literal, Span, TokenNode};
+use proc_macro2::{Literal, Span};
use std::str;
#[cfg(feature = "printing")]
use proc_macro2::Term;
#[cfg(feature = "parsing")]
use proc_macro2::TokenStream;
#[cfg(feature = "parsing")]
use {ParseError, Synom};
-#[cfg(any(feature = "printing", feature = "parsing"))]
+#[cfg(any(feature = "printing", feature = "parsing", feature = "derive"))]
use proc_macro2::TokenTree;
#[cfg(feature = "extra-traits")]
use std::hash::{Hash, Hasher};
ast_enum_of_structs! {
/// A Rust literal such as a string or integer or boolean.
///
@@ -36,67 +36,61 @@ ast_enum_of_structs! {
/// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
pub enum Lit {
/// A UTF-8 string literal: `"foo"`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Str(LitStr #manual_extra_traits {
token: Literal,
- pub span: Span,
}),
/// A byte string literal: `b"foo"`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub ByteStr(LitByteStr #manual_extra_traits {
token: Literal,
- pub span: Span,
}),
/// A byte literal: `b'f'`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Byte(LitByte #manual_extra_traits {
token: Literal,
- pub span: Span,
}),
/// A character literal: `'a'`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Char(LitChar #manual_extra_traits {
token: Literal,
- pub span: Span,
}),
/// An integer literal: `1` or `1u16`.
///
/// Holds up to 64 bits of data. Use `LitVerbatim` for any larger
/// integer literal.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Int(LitInt #manual_extra_traits {
token: Literal,
- pub span: Span,
}),
/// A floating point literal: `1f64` or `1.0e10f64`.
///
/// Must be finite. May not be infinte or NaN.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Float(LitFloat #manual_extra_traits {
token: Literal,
- pub span: Span,
}),
/// A boolean literal: `true` or `false`.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Bool(LitBool #manual_extra_traits {
pub value: bool,
@@ -105,126 +99,156 @@ ast_enum_of_structs! {
/// A raw token literal not interpreted by Syn, possibly because it
/// represents an integer larger than 64 bits.
///
/// *This type is available if Syn is built with the `"derive"` or
/// `"full"` feature.*
pub Verbatim(LitVerbatim #manual_extra_traits {
pub token: Literal,
- pub span: Span,
}),
}
}
impl LitStr {
pub fn new(value: &str, span: Span) -> Self {
+ let mut lit = Literal::string(value);
+ lit.set_span(span);
LitStr {
- token: Literal::string(value),
- span: span,
+ token: lit,
}
}
pub fn value(&self) -> String {
value::parse_lit_str(&self.token.to_string())
}
/// Parse a syntax tree node from the content of this string literal.
///
/// All spans in the syntax tree will point to the span of this `LitStr`.
#[cfg(feature = "parsing")]
pub fn parse<T: Synom>(&self) -> Result<T, ParseError> {
+ use proc_macro2::Group;
+
// Parse string literal into a token stream with every span equal to the
// original literal's span.
fn spanned_tokens(s: &LitStr) -> Result<TokenStream, ParseError> {
let stream = ::parse_str(&s.value())?;
- Ok(respan_token_stream(stream, s.span))
+ Ok(respan_token_stream(stream, s.span()))
}
// Token stream with every span replaced by the given one.
fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
stream.into_iter().map(|token| respan_token_tree(token, span)).collect()
}
// Token tree with every span replaced by the given one.
- fn respan_token_tree(token: TokenTree, span: Span) -> TokenTree {
- TokenTree {
- span: span,
- kind: match token.kind {
- TokenNode::Group(delimiter, nested) => {
- TokenNode::Group(delimiter, respan_token_stream(nested, span))
- }
- other => other,
- },
+ fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
+ match token {
+ TokenTree::Group(ref mut g) => {
+ let stream = respan_token_stream(g.stream().clone(), span);
+ *g = Group::new(g.delimiter(), stream);
+ g.set_span(span);
+ }
+ ref mut other => other.set_span(span),
}
+ token
}
spanned_tokens(self).and_then(::parse2)
}
+
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
}
impl LitByteStr {
pub fn new(value: &[u8], span: Span) -> Self {
- LitByteStr {
- token: Literal::byte_string(value),
- span: span,
- }
+ let mut token = Literal::byte_string(value);
+ token.set_span(span);
+ LitByteStr { token: token }
}
pub fn value(&self) -> Vec<u8> {
value::parse_lit_byte_str(&self.token.to_string())
}
+
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
}
impl LitByte {
pub fn new(value: u8, span: Span) -> Self {
- LitByte {
- token: Literal::byte_char(value),
- span: span,
- }
+ let mut token = Literal::u8_suffixed(value);
+ token.set_span(span);
+ LitByte { token: token }
}
pub fn value(&self) -> u8 {
value::parse_lit_byte(&self.token.to_string())
}
+
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
}
impl LitChar {
pub fn new(value: char, span: Span) -> Self {
- LitChar {
- token: Literal::character(value),
- span: span,
- }
+ let mut token = Literal::character(value);
+ token.set_span(span);
+ LitChar { token: token }
}
pub fn value(&self) -> char {
value::parse_lit_char(&self.token.to_string())
}
+
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
}
impl LitInt {
pub fn new(value: u64, suffix: IntSuffix, span: Span) -> Self {
- LitInt {
- token: match suffix {
- IntSuffix::Isize => Literal::isize(value as isize),
- IntSuffix::I8 => Literal::i8(value as i8),
- IntSuffix::I16 => Literal::i16(value as i16),
- IntSuffix::I32 => Literal::i32(value as i32),
- IntSuffix::I64 => Literal::i64(value as i64),
- IntSuffix::I128 => value::to_literal(&format!("{}i128", value)),
- IntSuffix::Usize => Literal::usize(value as usize),
- IntSuffix::U8 => Literal::u8(value as u8),
- IntSuffix::U16 => Literal::u16(value as u16),
- IntSuffix::U32 => Literal::u32(value as u32),
- IntSuffix::U64 => Literal::u64(value),
- IntSuffix::U128 => value::to_literal(&format!("{}u128", value)),
- IntSuffix::None => Literal::integer(value as i64),
- },
- span: span,
- }
+ let mut token = match suffix {
+ IntSuffix::Isize => Literal::isize_suffixed(value as isize),
+ IntSuffix::I8 => Literal::i8_suffixed(value as i8),
+ IntSuffix::I16 => Literal::i16_suffixed(value as i16),
+ IntSuffix::I32 => Literal::i32_suffixed(value as i32),
+ IntSuffix::I64 => Literal::i64_suffixed(value as i64),
+ IntSuffix::I128 => value::to_literal(&format!("{}i128", value)),
+ IntSuffix::Usize => Literal::usize_suffixed(value as usize),
+ IntSuffix::U8 => Literal::u8_suffixed(value as u8),
+ IntSuffix::U16 => Literal::u16_suffixed(value as u16),
+ IntSuffix::U32 => Literal::u32_suffixed(value as u32),
+ IntSuffix::U64 => Literal::u64_suffixed(value),
+ IntSuffix::U128 => value::to_literal(&format!("{}u128", value)),
+ IntSuffix::None => Literal::u64_unsuffixed(value),
+ };
+ token.set_span(span);
+ LitInt { token: token }
}
pub fn value(&self) -> u64 {
value::parse_lit_int(&self.token.to_string()).unwrap()
}
pub fn suffix(&self) -> IntSuffix {
let value = self.token.to_string();
@@ -243,43 +267,58 @@ impl LitInt {
("usize", IntSuffix::Usize),
] {
if value.ends_with(s) {
return suffix;
}
}
IntSuffix::None
}
+
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
}
impl LitFloat {
pub fn new(value: f64, suffix: FloatSuffix, span: Span) -> Self {
- LitFloat {
- token: match suffix {
- FloatSuffix::F32 => Literal::f32(value as f32),
- FloatSuffix::F64 => Literal::f64(value),
- FloatSuffix::None => Literal::float(value),
- },
- span: span,
- }
+ let mut token = match suffix {
+ FloatSuffix::F32 => Literal::f32_suffixed(value as f32),
+ FloatSuffix::F64 => Literal::f64_suffixed(value),
+ FloatSuffix::None => Literal::f64_unsuffixed(value),
+ };
+ token.set_span(span);
+ LitFloat { token: token }
}
pub fn value(&self) -> f64 {
value::parse_lit_float(&self.token.to_string())
}
pub fn suffix(&self) -> FloatSuffix {
let value = self.token.to_string();
for (s, suffix) in vec![("f32", FloatSuffix::F32), ("f64", FloatSuffix::F64)] {
if value.ends_with(s) {
return suffix;
}
}
FloatSuffix::None
}
+
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
}
macro_rules! lit_extra_traits {
($ty:ident, $field:ident) => {
#[cfg(feature = "extra-traits")]
impl Eq for $ty {}
#[cfg(feature = "extra-traits")]
@@ -296,16 +335,26 @@ macro_rules! lit_extra_traits {
H: Hasher,
{
self.$field.to_string().hash(state);
}
}
}
}
+impl LitVerbatim {
+ pub fn span(&self) -> Span {
+ self.token.span()
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.token.set_span(span)
+ }
+}
+
lit_extra_traits!(LitStr, token);
lit_extra_traits!(LitByteStr, token);
lit_extra_traits!(LitByte, token);
lit_extra_traits!(LitChar, token);
lit_extra_traits!(LitInt, token);
lit_extra_traits!(LitFloat, token);
lit_extra_traits!(LitBool, value);
lit_extra_traits!(LitVerbatim, token);
@@ -367,35 +416,35 @@ pub mod parsing {
use synom::Synom;
use buffer::Cursor;
use parse_error;
use synom::PResult;
impl Synom for Lit {
fn parse(input: Cursor) -> PResult<Self> {
match input.literal() {
- Some((span, lit, rest)) => {
+ Some((lit, rest)) => {
if lit.to_string().starts_with('/') {
// Doc comment literal which is not a Syn literal
parse_error()
} else {
- Ok((Lit::new(lit, span), rest))
+ Ok((Lit::new(lit), rest))
}
}
_ => match input.term() {
- Some((span, term, rest)) => Ok((
+ Some((term, rest)) => Ok((
Lit::Bool(LitBool {
value: if term.as_str() == "true" {
true
} else if term.as_str() == "false" {
false
} else {
return parse_error();
},
- span: span,
+ span: term.span(),
}),
rest,
)),
_ => parse_error(),
},
}
}
@@ -456,83 +505,60 @@ pub mod parsing {
#[cfg(feature = "printing")]
mod printing {
use super::*;
use quote::{ToTokens, Tokens};
impl ToTokens for LitStr {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
impl ToTokens for LitByteStr {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
impl ToTokens for LitByte {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
impl ToTokens for LitChar {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
impl ToTokens for LitInt {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
impl ToTokens for LitFloat {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
impl ToTokens for LitBool {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Term(Term::intern(if self.value { "true" } else { "false" })),
- });
+ let s = if self.value { "true" } else { "false" };
+ tokens.append(Term::new(s, self.span));
}
}
impl ToTokens for LitVerbatim {
fn to_tokens(&self, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: self.span,
- kind: TokenNode::Literal(self.token.clone()),
- });
+ self.token.to_tokens(tokens);
}
}
}
mod value {
use super::*;
use std::char;
use std::ops::{Index, RangeFrom};
@@ -545,68 +571,61 @@ mod value {
/// doc comments are considered by proc-macro2 to be literals but in Syn
/// they are [`Attribute`].
///
/// [`Attribute`]: struct.Attribute.html
///
/// # Panics
///
/// Panics if the input is a doc comment literal.
- pub fn new(token: Literal, span: Span) -> Self {
+ pub fn new(token: Literal) -> Self {
let value = token.to_string();
match value::byte(&value, 0) {
b'"' | b'r' => {
return Lit::Str(LitStr {
token: token,
- span: span,
})
}
b'b' => match value::byte(&value, 1) {
b'"' | b'r' => {
return Lit::ByteStr(LitByteStr {
token: token,
- span: span,
})
}
b'\'' => {
return Lit::Byte(LitByte {
token: token,
- span: span,
})
}
_ => {}
},
b'\'' => {
return Lit::Char(LitChar {
token: token,
- span: span,
})
}
b'0'...b'9' => if number_is_int(&value) {
return Lit::Int(LitInt {
token: token,
- span: span,
});
} else if number_is_float(&value) {
return Lit::Float(LitFloat {
token: token,
- span: span,
});
} else {
// number overflow
return Lit::Verbatim(LitVerbatim {
token: token,
- span: span,
});
},
_ => if value == "true" || value == "false" {
return Lit::Bool(LitBool {
value: value == "true",
- span: span,
+ span: token.span(),
});
},
}
panic!("Unrecognized literal: {}", value);
}
}
@@ -1015,14 +1034,14 @@ mod value {
bytes.truncate(write);
let input = String::from_utf8(bytes).unwrap();
let end = input.find('f').unwrap_or_else(|| input.len());
input[..end].parse().unwrap()
}
pub fn to_literal(s: &str) -> Literal {
let stream = s.parse::<TokenStream>().unwrap();
- match stream.into_iter().next().unwrap().kind {
- TokenNode::Literal(l) => l,
+ match stream.into_iter().next().unwrap() {
+ TokenTree::Literal(l) => l,
_ => unreachable!(),
}
}
}
--- a/third_party/rust/syn/src/punctuated.rs
+++ b/third_party/rust/syn/src/punctuated.rs
@@ -22,16 +22,18 @@
//!
//! [`Punctuated<T, P>`]: struct.Punctuated.html
//!
//! ```text
//! a_function_call(arg1, arg2, arg3);
//! ^^^^^ ~~~~~ ^^^^
//! ```
+#[cfg(any(feature = "full", feature = "derive"))]
+use std::iter;
use std::iter::FromIterator;
use std::ops::{Index, IndexMut};
use std::slice;
use std::vec;
#[cfg(feature = "extra-traits")]
use std::fmt::{self, Debug};
#[cfg(feature = "parsing")]
@@ -95,27 +97,31 @@ impl<T, P> Punctuated<T, P> {
.last_mut()
.map(|&mut (ref mut t, ref mut d)| match *d {
Some(ref mut d) => Pair::Punctuated(t, d),
None => Pair::End(t),
})
}
/// Returns an iterator over borrowed syntax tree nodes of type `&T`.
- pub fn iter(&self) -> Iter<T, P> {
+ pub fn iter(&self) -> Iter<T> {
Iter {
- inner: self.inner.iter(),
+ inner: Box::new(PrivateIter {
+ inner: self.inner.iter(),
+ }),
}
}
/// Returns an iterator over mutably borrowed syntax tree nodes of type
/// `&mut T`.
- pub fn iter_mut(&mut self) -> IterMut<T, P> {
+ pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut {
- inner: self.inner.iter_mut(),
+ inner: Box::new(PrivateIterMut {
+ inner: self.inner.iter_mut(),
+ }),
}
}
/// Returns an iterator over the contents of this sequence as borrowed
/// punctuated pairs.
pub fn pairs(&self) -> Pairs<T, P> {
Pairs {
inner: self.inner.iter(),
@@ -285,26 +291,26 @@ impl<T, P> IntoIterator for Punctuated<T
IntoIter {
inner: self.inner.into_iter(),
}
}
}
impl<'a, T, P> IntoIterator for &'a Punctuated<T, P> {
type Item = &'a T;
- type IntoIter = Iter<'a, T, P>;
+ type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Self::IntoIter {
Punctuated::iter(self)
}
}
impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P> {
type Item = &'a mut T;
- type IntoIter = IterMut<'a, T, P>;
+ type IntoIter = IterMut<'a, T>;
fn into_iter(self) -> Self::IntoIter {
Punctuated::iter_mut(self)
}
}
impl<T, P> Default for Punctuated<T, P> {
fn default() -> Self {
@@ -389,49 +395,73 @@ impl<T, P> Iterator for IntoIter<T, P> {
}
}
/// An iterator over borrowed values of type `&T`.
///
/// Refer to the [module documentation] for details about punctuated sequences.
///
/// [module documentation]: index.html
-pub struct Iter<'a, T: 'a, P: 'a> {
+pub struct Iter<'a, T: 'a> {
+ inner: Box<Iterator<Item = &'a T> + 'a>,
+}
+
+struct PrivateIter<'a, T: 'a, P: 'a> {
inner: slice::Iter<'a, (T, Option<P>)>,
}
#[cfg(any(feature = "full", feature = "derive"))]
-impl<'a, T, P> Iter<'a, T, P> {
+impl<'a, T> Iter<'a, T> {
// Not public API.
#[doc(hidden)]
pub fn private_empty() -> Self {
Iter {
- inner: [].iter(),
+ inner: Box::new(iter::empty()),
}
}
}
-impl<'a, T, P> Iterator for Iter<'a, T, P> {
+impl<'a, T> Iterator for Iter<'a, T> {
+ type Item = &'a T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.inner.next()
+ }
+}
+
+impl<'a, T, P> Iterator for PrivateIter<'a, T, P> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|pair| &pair.0)
}
}
/// An iterator over mutably borrowed values of type `&mut T`.
///
/// Refer to the [module documentation] for details about punctuated sequences.
///
/// [module documentation]: index.html
-pub struct IterMut<'a, T: 'a, P: 'a> {
+pub struct IterMut<'a, T: 'a> {
+ inner: Box<Iterator<Item = &'a mut T> + 'a>,
+}
+
+struct PrivateIterMut<'a, T: 'a, P: 'a> {
inner: slice::IterMut<'a, (T, Option<P>)>,
}
-impl<'a, T, P> Iterator for IterMut<'a, T, P> {
+impl<'a, T> Iterator for IterMut<'a, T> {
+ type Item = &'a mut T;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.inner.next()
+ }
+}
+
+impl<'a, T, P> Iterator for PrivateIterMut<'a, T, P> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|pair| &mut pair.0)
}
}
/// A single syntax tree node of type `T` followed by its trailing punctuation
--- a/third_party/rust/syn/src/spanned.rs
+++ b/third_party/rust/syn/src/spanned.rs
@@ -43,19 +43,17 @@
//!
//! # const IGNORE_TOKENS: &str = stringify! {
//! #[proc_macro_derive(MyMacro)]
//! # };
//! pub fn my_macro(input: TokenStream) -> TokenStream {
//! # let ty = get_a_type();
//! /* ... */
//!
-//! let def_site = Span::def_site();
-//! let ty_span = ty.span().resolved_at(def_site);
-//! let assert_sync = quote_spanned! {ty_span=>
+//! let assert_sync = quote_spanned! {ty.span()=>
//! struct _AssertSync where #ty: Sync;
//! };
//!
//! /* ... */
//! # input
//! }
//! #
//! # fn get_a_type() -> Type {
@@ -73,23 +71,17 @@
//! error[E0277]: the trait bound `*const i32: std::marker::Sync` is not satisfied
//! --> src/main.rs:10:21
//! |
//! 10 | bad_field: *const i32,
//! | ^^^^^^^^^^ `*const i32` cannot be shared between threads safely
//! ```
//!
//! In this technique, using the `Type`'s span for the error message makes the
-//! error appear in the correct place underlining the right type. But it is
-//! **incredibly important** that the span for the assertion is **resolved** at
-//! the procedural macro definition site rather than at the `Type`'s span. This
-//! way we guarantee that it refers to the `Sync` trait that we expect. If the
-//! assertion were **resolved** at the same place that `ty` is resolved, the
-//! user could circumvent the check by defining their own `Sync` trait that is
-//! implemented for their type.
+//! error appear in the correct place underlining the right type.
use proc_macro2::{Span, TokenStream};
use quote::{ToTokens, Tokens};
/// A trait that can provide the `Span` of the complete contents of a syntax
/// tree node.
///
/// This trait is automatically implemented for all types that implement
@@ -117,36 +109,36 @@ where
{
#[cfg(procmacro2_semver_exempt)]
fn span(&self) -> Span {
let mut tokens = Tokens::new();
self.to_tokens(&mut tokens);
let token_stream = TokenStream::from(tokens);
let mut iter = token_stream.into_iter();
let mut span = match iter.next() {
- Some(tt) => tt.span,
+ Some(tt) => tt.span(),
None => {
return Span::call_site();
}
};
for tt in iter {
- if let Some(joined) = span.join(tt.span) {
+ if let Some(joined) = span.join(tt.span()) {
span = joined;
}
}
span
}
#[cfg(not(procmacro2_semver_exempt))]
fn span(&self) -> Span {
let mut tokens = Tokens::new();
self.to_tokens(&mut tokens);
let token_stream = TokenStream::from(tokens);
let mut iter = token_stream.into_iter();
// We can't join spans without procmacro2_semver_exempt so just grab the
// first one.
match iter.next() {
- Some(tt) => tt.span,
+ Some(tt) => tt.span(),
None => Span::call_site(),
}
}
}
--- a/third_party/rust/syn/src/synom.rs
+++ b/third_party/rust/syn/src/synom.rs
@@ -144,16 +144,17 @@
//! - [`reject!`](../macro.reject.html)
//! - [`switch!`](../macro.switch.html)
//! - [`syn!`](../macro.syn.html)
//! - [`tuple!`](../macro.tuple.html)
//! - [`value!`](../macro.value.html)
//!
//! *This module is available if Syn is built with the `"parsing"` feature.*
+#[cfg(feature = "proc-macro")]
use proc_macro;
use proc_macro2;
pub use error::{PResult, ParseError};
use buffer::{Cursor, TokenBuffer};
/// Parsing interface implemented by all types that can be parsed in a default
@@ -162,16 +163,45 @@ use buffer::{Cursor, TokenBuffer};
/// Refer to the [module documentation] for details about parsing in Syn.
///
/// [module documentation]: index.html
///
/// *This trait is available if Syn is built with the `"parsing"` feature.*
pub trait Synom: Sized {
fn parse(input: Cursor) -> PResult<Self>;
+ /// A short name of the type being parsed.
+ ///
+ /// The description should only be used for a simple name. It should not
+ /// contain newlines or sentence-ending punctuation, to facilitate embedding in
+ /// larger user-facing strings. Syn will use this description when building
+ /// error messages about parse failures.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use syn::buffer::Cursor;
+ /// # use syn::synom::{Synom, PResult};
+ /// #
+ /// struct ExprMacro {
+ /// // ...
+ /// }
+ ///
+ /// impl Synom for ExprMacro {
+ /// # fn parse(input: Cursor) -> PResult<Self> { unimplemented!() }
+ /// // fn parse(...) -> ... { ... }
+ ///
+ /// fn description() -> Option<&'static str> {
+ /// // Will result in messages like
+ /// //
+ /// // "failed to parse macro invocation expression: $reason"
+ /// Some("macro invocation expression")
+ /// }
+ /// }
+ /// ```
fn description() -> Option<&'static str> {
None
}
}
impl Synom for proc_macro2::TokenStream {
fn parse(input: Cursor) -> PResult<Self> {
Ok((input.token_stream(), Cursor::empty()))
@@ -191,16 +221,17 @@ impl Synom for proc_macro2::TokenStream
/// *This trait is available if Syn is built with the `"parsing"` feature.*
pub trait Parser: Sized {
type Output;
/// Parse a proc-macro2 token stream into the chosen syntax tree node.
fn parse2(self, tokens: proc_macro2::TokenStream) -> Result<Self::Output, ParseError>;
/// Parse tokens of source code into the chosen syntax tree node.
+ #[cfg(feature = "proc-macro")]
fn parse(self, tokens: proc_macro::TokenStream) -> Result<Self::Output, ParseError> {
self.parse2(tokens.into())
}
/// Parse a string of Rust code into the chosen syntax tree node.
///
/// # Hygiene
///
--- a/third_party/rust/syn/src/token.rs
+++ b/third_party/rust/syn/src/token.rs
@@ -131,17 +131,17 @@ macro_rules! token_punct {
impl $name {
pub fn new(span: Span) -> Self {
$name([span; $len])
}
}
impl ::std::default::Default for $name {
fn default() -> Self {
- $name([Span::def_site(); $len])
+ $name([Span::call_site(); $len])
}
}
#[cfg(feature = "extra-traits")]
impl ::std::fmt::Debug for $name {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.write_str(stringify!($name))
}
@@ -198,17 +198,17 @@ macro_rules! token_keyword {
/// Don't try to remember the name of this type -- use the [`Token!`]
/// macro instead.
///
/// [`Token!`]: index.html
pub struct $name(pub Span);
impl ::std::default::Default for $name {
fn default() -> Self {
- $name(Span::def_site())
+ $name(Span::call_site())
}
}
#[cfg(feature = "extra-traits")]
impl ::std::fmt::Debug for $name {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.write_str(stringify!($name))
}
@@ -260,17 +260,17 @@ macro_rules! token_keyword {
macro_rules! token_delimiter {
(#[$doc:meta] $s:tt pub struct $name:ident) => {
#[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
#[$doc]
pub struct $name(pub Span);
impl ::std::default::Default for $name {
fn default() -> Self {
- $name(Span::def_site())
+ $name(Span::call_site())
}
}
#[cfg(feature = "extra-traits")]
impl ::std::fmt::Debug for $name {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.write_str(stringify!($name))
}
@@ -351,17 +351,17 @@ tokens! {
"|=" pub struct OrEq/2 /// `|=`
"||" pub struct OrOr/2 /// `||`
"#" pub struct Pound/1 /// `#`
"?" pub struct Question/1 /// `?`
"->" pub struct RArrow/2 /// `->`
"<-" pub struct LArrow/2 /// `<-`
"%" pub struct Rem/1 /// `%`
"%=" pub struct RemEq/2 /// `%=`
- "=>" pub struct Rocket/2 /// `=>`
+ "=>" pub struct FatArrow/2 /// `=>`
";" pub struct Semi/1 /// `;`
"<<" pub struct Shl/2 /// `<<`
"<<=" pub struct ShlEq/3 /// `<<=`
">>" pub struct Shr/2 /// `>>`
">>=" pub struct ShrEq/3 /// `>>=`
"*" pub struct Star/1 /// `*`
"-" pub struct Sub/1 /// `-`
"-=" pub struct SubEq/2 /// `-=`
@@ -459,17 +459,17 @@ macro_rules! Token {
(|=) => { $crate::token::OrEq };
(||) => { $crate::token::OrOr };
(#) => { $crate::token::Pound };
(?) => { $crate::token::Question };
(->) => { $crate::token::RArrow };
(<-) => { $crate::token::LArrow };
(%) => { $crate::token::Rem };
(%=) => { $crate::token::RemEq };
- (=>) => { $crate::token::Rocket };
+ (=>) => { $crate::token::FatArrow };
(;) => { $crate::token::Semi };
(<<) => { $crate::token::Shl };
(<<=) => { $crate::token::ShlEq };
(>>) => { $crate::token::Shr };
(>>=) => { $crate::token::ShrEq };
(*) => { $crate::token::Star };
(-) => { $crate::token::Sub };
(-=) => { $crate::token::SubEq };
@@ -558,17 +558,17 @@ macro_rules! punct {
($i:expr, |=) => { call!($i, <$crate::token::OrEq as $crate::synom::Synom>::parse) };
($i:expr, ||) => { call!($i, <$crate::token::OrOr as $crate::synom::Synom>::parse) };
($i:expr, #) => { call!($i, <$crate::token::Pound as $crate::synom::Synom>::parse) };
($i:expr, ?) => { call!($i, <$crate::token::Question as $crate::synom::Synom>::parse) };
($i:expr, ->) => { call!($i, <$crate::token::RArrow as $crate::synom::Synom>::parse) };
($i:expr, <-) => { call!($i, <$crate::token::LArrow as $crate::synom::Synom>::parse) };
($i:expr, %) => { call!($i, <$crate::token::Rem as $crate::synom::Synom>::parse) };
($i:expr, %=) => { call!($i, <$crate::token::RemEq as $crate::synom::Synom>::parse) };
- ($i:expr, =>) => { call!($i, <$crate::token::Rocket as $crate::synom::Synom>::parse) };
+ ($i:expr, =>) => { call!($i, <$crate::token::FatArrow as $crate::synom::Synom>::parse) };
($i:expr, ;) => { call!($i, <$crate::token::Semi as $crate::synom::Synom>::parse) };
($i:expr, <<) => { call!($i, <$crate::token::Shl as $crate::synom::Synom>::parse) };
($i:expr, <<=) => { call!($i, <$crate::token::ShlEq as $crate::synom::Synom>::parse) };
($i:expr, >>) => { call!($i, <$crate::token::Shr as $crate::synom::Synom>::parse) };
($i:expr, >>=) => { call!($i, <$crate::token::ShrEq as $crate::synom::Synom>::parse) };
($i:expr, *) => { call!($i, <$crate::token::Star as $crate::synom::Synom>::parse) };
($i:expr, -) => { call!($i, <$crate::token::Sub as $crate::synom::Synom>::parse) };
($i:expr, -=) => { call!($i, <$crate::token::SubEq as $crate::synom::Synom>::parse) };
@@ -658,42 +658,42 @@ mod parsing {
[spans[0], spans[1], spans[2]]
}
}
pub fn punct<'a, T, R>(s: &str, mut tokens: Cursor<'a>, new: fn(T) -> R) -> PResult<'a, R>
where
T: FromSpans,
{
- let mut spans = [Span::def_site(); 3];
+ let mut spans = [Span::call_site(); 3];
assert!(s.len() <= spans.len());
let chars = s.chars();
for (i, (ch, slot)) in chars.zip(&mut spans).enumerate() {
match tokens.op() {
- Some((span, op, kind, rest)) if op == ch => {
+ Some((op, rest)) if op.op() == ch => {
if i != s.len() - 1 {
- match kind {
+ match op.spacing() {
Spacing::Joint => {}
_ => return parse_error(),
}
}
- *slot = span;
+ *slot = op.span();
tokens = rest;
}
_ => return parse_error(),
}
}
Ok((new(T::from_spans(&spans)), tokens))
}
pub fn keyword<'a, T>(keyword: &str, tokens: Cursor<'a>, new: fn(Span) -> T) -> PResult<'a, T> {
- if let Some((span, term, rest)) = tokens.term() {
+ if let Some((term, rest)) = tokens.term() {
if term.as_str() == keyword {
- return Ok((new(span), rest));
+ return Ok((new(term.span()), rest));
}
}
parse_error()
}
pub fn delim<'a, F, R, T>(
delim: &str,
tokens: Cursor<'a>,
@@ -723,57 +723,51 @@ mod parsing {
}
}
parse_error()
}
}
#[cfg(feature = "printing")]
mod printing {
- use proc_macro2::{Delimiter, Spacing, Span, Term, TokenNode, TokenTree};
+ use proc_macro2::{Delimiter, Spacing, Span, Term, Op, Group};
use quote::Tokens;
pub fn punct(s: &str, spans: &[Span], tokens: &mut Tokens) {
assert_eq!(s.len(), spans.len());
let mut chars = s.chars();
let mut spans = spans.iter();
let ch = chars.next_back().unwrap();
let span = spans.next_back().unwrap();
for (ch, span) in chars.zip(spans) {
- tokens.append(TokenTree {
- span: *span,
- kind: TokenNode::Op(ch, Spacing::Joint),
- });
+ let mut op = Op::new(ch, Spacing::Joint);
+ op.set_span(*span);
+ tokens.append(op);
}
- tokens.append(TokenTree {
- span: *span,
- kind: TokenNode::Op(ch, Spacing::Alone),
- });
+ let mut op = Op::new(ch, Spacing::Alone);
+ op.set_span(*span);
+ tokens.append(op);
}
pub fn keyword(s: &str, span: &Span, tokens: &mut Tokens) {
- tokens.append(TokenTree {
- span: *span,
- kind: TokenNode::Term(Term::intern(s)),
- });
+ tokens.append(Term::new(s, *span));
}
pub fn delim<F>(s: &str, span: &Span, tokens: &mut Tokens, f: F)
where
F: FnOnce(&mut Tokens),
{
let delim = match s {
"(" => Delimiter::Parenthesis,
"[" => Delimiter::Bracket,
"{" => Delimiter::Brace,
" " => Delimiter::None,
_ => panic!("unknown delimiter: {}", s),
};
let mut inner = Tokens::new();
f(&mut inner);
- tokens.append(TokenTree {
- span: *span,
- kind: TokenNode::Group(delim, inner.into()),
- });
+ let mut g = Group::new(delim, inner.into());
+ g.set_span(*span);
+ tokens.append(g);
}
}
--- a/third_party/rust/syn/src/tt.rs
+++ b/third_party/rust/syn/src/tt.rs
@@ -14,145 +14,131 @@ use synom::PResult;
use token::{Brace, Bracket, Paren};
#[cfg(feature = "parsing")]
use {parse_error, MacroDelimiter};
#[cfg(feature = "extra-traits")]
use std::hash::{Hash, Hasher};
#[cfg(any(feature = "parsing", feature = "extra-traits"))]
-use proc_macro2::{Delimiter, TokenNode, TokenStream, TokenTree};
+use proc_macro2::{Delimiter, TokenStream, TokenTree};
#[cfg(feature = "parsing")]
pub fn delimited(input: Cursor) -> PResult<(MacroDelimiter, TokenStream)> {
- match input.token_tree() {
- Some((
- TokenTree {
- span,
- kind: TokenNode::Group(delimiter, tts),
- },
- rest,
- )) => {
- let delimiter = match delimiter {
- Delimiter::Parenthesis => MacroDelimiter::Paren(Paren(span)),
- Delimiter::Brace => MacroDelimiter::Brace(Brace(span)),
- Delimiter::Bracket => MacroDelimiter::Bracket(Bracket(span)),
- Delimiter::None => return parse_error(),
- };
- Ok(((delimiter, tts), rest))
- }
- _ => parse_error(),
+ if let Some((TokenTree::Group(g), rest)) = input.token_tree() {
+ let span = g.span();
+ let delimiter = match g.delimiter() {
+ Delimiter::Parenthesis => MacroDelimiter::Paren(Paren(span)),
+ Delimiter::Brace => MacroDelimiter::Brace(Brace(span)),
+ Delimiter::Bracket => MacroDelimiter::Bracket(Bracket(span)),
+ Delimiter::None => return parse_error(),
+ };
+
+ return Ok(((delimiter, g.stream().clone()), rest))
}
+ parse_error()
}
#[cfg(all(feature = "full", feature = "parsing"))]
pub fn braced(input: Cursor) -> PResult<(Brace, TokenStream)> {
- match input.token_tree() {
- Some((
- TokenTree {
- span,
- kind: TokenNode::Group(Delimiter::Brace, tts),
- },
- rest,
- )) => Ok(((Brace(span), tts), rest)),
- _ => parse_error(),
+ if let Some((TokenTree::Group(g), rest)) = input.token_tree() {
+ if g.delimiter() == Delimiter::Brace {
+ return Ok(((Brace(g.span()), g.stream().clone()), rest))
+ }
}
+ parse_error()
}
#[cfg(all(feature = "full", feature = "parsing"))]
pub fn parenthesized(input: Cursor) -> PResult<(Paren, TokenStream)> {
- match input.token_tree() {
- Some((
- TokenTree {
- span,
- kind: TokenNode::Group(Delimiter::Parenthesis, tts),
- },
- rest,
- )) => Ok(((Paren(span), tts), rest)),
- _ => parse_error(),
+ if let Some((TokenTree::Group(g), rest)) = input.token_tree() {
+ if g.delimiter() == Delimiter::Parenthesis {
+ return Ok(((Paren(g.span()), g.stream().clone()), rest))
+ }
}
+ parse_error()
}
#[cfg(feature = "extra-traits")]
pub struct TokenTreeHelper<'a>(pub &'a TokenTree);
#[cfg(feature = "extra-traits")]
impl<'a> PartialEq for TokenTreeHelper<'a> {
fn eq(&self, other: &Self) -> bool {
use proc_macro2::Spacing;
- match (&self.0.kind, &other.0.kind) {
- (&TokenNode::Group(d1, ref s1), &TokenNode::Group(d2, ref s2)) => {
- match (d1, d2) {
+ match (self.0, other.0) {
+ (&TokenTree::Group(ref g1), &TokenTree::Group(ref g2)) => {
+ match (g1.delimiter(), g2.delimiter()) {
(Delimiter::Parenthesis, Delimiter::Parenthesis)
| (Delimiter::Brace, Delimiter::Brace)
| (Delimiter::Bracket, Delimiter::Bracket)
| (Delimiter::None, Delimiter::None) => {}
_ => return false,
}
- let s1 = s1.clone().into_iter();
- let mut s2 = s2.clone().into_iter();
+ let s1 = g1.stream().clone().into_iter();
+ let mut s2 = g2.stream().clone().into_iter();
for item1 in s1 {
let item2 = match s2.next() {
Some(item) => item,
None => return false,
};
if TokenTreeHelper(&item1) != TokenTreeHelper(&item2) {
return false;
}
}
s2.next().is_none()
}
- (&TokenNode::Op(o1, k1), &TokenNode::Op(o2, k2)) => {
- o1 == o2 && match (k1, k2) {
+ (&TokenTree::Op(ref o1), &TokenTree::Op(ref o2)) => {
+ o1.op() == o2.op() && match (o1.spacing(), o2.spacing()) {
(Spacing::Alone, Spacing::Alone) | (Spacing::Joint, Spacing::Joint) => true,
_ => false,
}
}
- (&TokenNode::Literal(ref l1), &TokenNode::Literal(ref l2)) => {
+ (&TokenTree::Literal(ref l1), &TokenTree::Literal(ref l2)) => {
l1.to_string() == l2.to_string()
}
- (&TokenNode::Term(ref s1), &TokenNode::Term(ref s2)) => s1.as_str() == s2.as_str(),
+ (&TokenTree::Term(ref s1), &TokenTree::Term(ref s2)) => s1.as_str() == s2.as_str(),
_ => false,
}
}
}
#[cfg(feature = "extra-traits")]
impl<'a> Hash for TokenTreeHelper<'a> {
fn hash<H: Hasher>(&self, h: &mut H) {
use proc_macro2::Spacing;
- match self.0.kind {
- TokenNode::Group(delim, ref stream) => {
+ match *self.0 {
+ TokenTree::Group(ref g) => {
0u8.hash(h);
- match delim {
+ match g.delimiter() {
Delimiter::Parenthesis => 0u8.hash(h),
Delimiter::Brace => 1u8.hash(h),
Delimiter::Bracket => 2u8.hash(h),
Delimiter::None => 3u8.hash(h),
}
- for item in stream.clone() {
+ for item in g.stream().clone() {
TokenTreeHelper(&item).hash(h);
}
0xffu8.hash(h); // terminator w/ a variant we don't normally hash
}
- TokenNode::Op(op, kind) => {
+ TokenTree::Op(ref op) => {
1u8.hash(h);
- op.hash(h);
- match kind {
+ op.op().hash(h);
+ match op.spacing() {
Spacing::Alone => 0u8.hash(h),
Spacing::Joint => 1u8.hash(h),
}
}
- TokenNode::Literal(ref lit) => (2u8, lit.to_string()).hash(h),
- TokenNode::Term(ref word) => (3u8, word.as_str()).hash(h),
+ TokenTree::Literal(ref lit) => (2u8, lit.to_string()).hash(h),
+ TokenTree::Term(ref word) => (3u8, word.as_str()).hash(h),
}
}
}
#[cfg(feature = "extra-traits")]
pub struct TokenStreamHelper<'a>(pub &'a TokenStream);
#[cfg(feature = "extra-traits")]
--- a/third_party/rust/syn/src/ty.rs
+++ b/third_party/rust/syn/src/ty.rs
@@ -708,17 +708,17 @@ mod printing {
self.bang_token.to_tokens(tokens);
}
}
impl ToTokens for TypeTuple {
fn to_tokens(&self, tokens: &mut Tokens) {
self.paren_token.surround(tokens, |tokens| {
self.elems.to_tokens(tokens);
- })
+ });
}
}
impl ToTokens for TypePath {
fn to_tokens(&self, tokens: &mut Tokens) {
PathTokens(&self.qself, &self.path).to_tokens(tokens);
}
}
deleted file mode 100644
--- a/third_party/rust/synom/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{"Cargo.toml":"0771c67fca19d4b8d9744501ee3b5a48b7be5426831d18907490781a0fdb630f","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"b2d43372ff5db084b4f2ef5178e1fbdba83e0f05a9cfc298f188cc130e8de794","src/helper.rs":"0c827ed560f7d97edaf1082281626508a74de1a87886d1bda8bf4383399fb87b","src/lib.rs":"93c66afd80f9806ddac92b9d3a6382fad34c6b52cb3a8d37ae1067ae1ed5bec9","src/space.rs":"6fe05780dd47ed9d264bb436cbccf385f86bafc4debdd39bf250099b8210f660"},"package":"27e31aa4b09b9f4cb12dff3c30ba503e17b1a624413d764d32dab76e3920e5bc"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/synom/Cargo.toml
+++ /dev/null
@@ -1,20 +0,0 @@
-[package]
-name = "synom"
-version = "0.11.2"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
-description = "Stripped-down Nom parser used by Syn"
-repository = "https://github.com/dtolnay/syn"
-documentation = "https://docs.rs/synom/"
-categories = ["development-tools::procedural-macro-helpers"]
-readme = "../README.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-
-[dependencies]
-unicode-xid = "0.0.4"
-
-[dev-dependencies.syn]
-version = "0.11"
-path = ".."
-features = ["parsing", "full"]
-default-features = false
deleted file mode 100644
--- a/third_party/rust/synom/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2016 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/synom/README.md
+++ /dev/null
@@ -1,199 +0,0 @@
-Nom parser for Rust source code
-===============================
-
-[](https://travis-ci.org/dtolnay/syn)
-[](https://crates.io/crates/syn)
-[](https://dtolnay.github.io/syn/syn/)
-
-Parse Rust source code without a Syntex dependency, intended for use with
-[Macros 1.1](https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md).
-
-Designed for fast compile time.
-
-- Compile time for `syn` (from scratch including all dependencies): **6 seconds**
-- Compile time for the `syntex`/`quasi`/`aster` stack: **60+ seconds**
-
-If you get stuck with Macros 1.1 I am happy to provide help even if the issue is
-not related to syn. Please file a ticket in this repo.
-
-## Usage with Macros 1.1
-
-```toml
-[dependencies]
-syn = "0.11"
-quote = "0.3"
-
-[lib]
-proc-macro = true
-```
-
-```rust
-extern crate proc_macro;
-use proc_macro::TokenStream;
-
-extern crate syn;
-
-#[macro_use]
-extern crate quote;
-
-#[proc_macro_derive(MyMacro)]
-pub fn my_macro(input: TokenStream) -> TokenStream {
- let source = input.to_string();
-
- // Parse the string representation into a syntax tree
- let ast = syn::parse_derive_input(&source).unwrap();
-
- // Build the output, possibly using quasi-quotation
- let expanded = quote! {
- // ...
- };
-
- // Parse back to a token stream and return it
- expanded.parse().unwrap()
-}
-```
-
-## Complete example
-
-Suppose we have the following simple trait which returns the number of fields in
-a struct:
-
-```rust
-trait NumFields {
- fn num_fields() -> usize;
-}
-```
-
-A complete Macros 1.1 implementation of `#[derive(NumFields)]` based on `syn`
-and [`quote`](https://github.com/dtolnay/quote) looks like this:
-
-```rust
-extern crate proc_macro;
-use proc_macro::TokenStream;
-
-extern crate syn;
-
-#[macro_use]
-extern crate quote;
-
-#[proc_macro_derive(NumFields)]
-pub fn num_fields(input: TokenStream) -> TokenStream {
- let source = input.to_string();
-
- // Parse the string representation into a syntax tree
- let ast = syn::parse_derive_input(&source).unwrap();
-
- // Build the output
- let expanded = expand_num_fields(&ast);
-
- // Return the generated impl as a TokenStream
- expanded.parse().unwrap()
-}
-
-fn expand_num_fields(ast: &syn::DeriveInput) -> quote::Tokens {
- let n = match ast.body {
- syn::Body::Struct(ref data) => data.fields().len(),
- syn::Body::Enum(_) => panic!("#[derive(NumFields)] can only be used with structs"),
- };
-
- // Used in the quasi-quotation below as `#name`
- let name = &ast.ident;
-
- // Helper is provided for handling complex generic types correctly and effortlessly
- let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-
- quote! {
- // The generated impl
- impl #impl_generics ::mycrate::NumFields for #name #ty_generics #where_clause {
- fn num_fields() -> usize {
- #n
- }
- }
- }
-}
-```
-
-## Testing
-
-Macros 1.1 has a restriction that your proc-macro crate must export nothing but
-`proc_macro_derive` functions, and also `proc_macro_derive` procedural macros
-cannot be used from the same crate in which they are defined. These restrictions
-may be lifted in the future but for now they make writing tests a bit trickier
-than for other types of code.
-
-In particular, you will not be able to write test functions like `#[test] fn
-it_works() { ... }` in line with your code. Instead, either put tests in a
-[`tests` directory](https://doc.rust-lang.org/book/testing.html#the-tests-directory)
-or in a separate crate entirely.
-
-Additionally, if your procedural macro implements a particular trait, that trait
-must be defined in a separate crate from the procedural macro.
-
-As a concrete example, suppose your procedural macro crate is called `my_derive`
-and it implements a trait called `my_crate::MyTrait`. Your unit tests for the
-procedural macro can go in `my_derive/tests/test.rs` or into a separate crate
-`my_tests/tests/test.rs`. Either way the test would look something like this:
-
-```rust
-#[macro_use]
-extern crate my_derive;
-
-extern crate my_crate;
-use my_crate::MyTrait;
-
-#[test]
-fn it_works() {
- #[derive(MyTrait)]
- struct S { /* ... */ }
-
- /* test the thing */
-}
-```
-
-## Debugging
-
-When developing a procedural macro it can be helpful to look at what the
-generated code looks like. Use `cargo rustc -- -Zunstable-options
---pretty=expanded` or the
-[`cargo expand`](https://github.com/dtolnay/cargo-expand) subcommand.
-
-To show the expanded code for some crate that uses your procedural macro, run
-`cargo expand` from that crate. To show the expanded code for one of your own
-test cases, run `cargo expand --test the_test_case` where the last argument is
-the name of the test file without the `.rs` extension.
-
-This write-up by Brandon W Maister discusses debugging in more detail:
-[Debugging Rust's new Custom Derive
-system](https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system/).
-
-## Optional features
-
-Syn puts a lot of functionality behind optional features in order to optimize
-compile time for the most common use cases. These are the available features and
-their effect on compile time. Dependencies are included in the compile times.
-
-Features | Compile time | Functionality
---- | --- | ---
-*(none)* | 3 sec | The data structures representing the AST of Rust structs, enums, and types.
-parsing | 6 sec | Parsing Rust source code containing structs and enums into an AST.
-printing | 4 sec | Printing an AST of structs and enums as Rust source code.
-**parsing, printing** | **6 sec** | **This is the default.** Parsing and printing of Rust structs and enums. This is typically what you want for implementing Macros 1.1 custom derives.
-full | 4 sec | The data structures representing the full AST of all possible Rust code.
-full, parsing | 9 sec | Parsing any valid Rust source code to an AST.
-full, printing | 6 sec | Turning an AST into Rust source code.
-full, parsing, printing | 11 sec | Parsing and printing any Rust syntax.
-
-## License
-
-Licensed under either of
-
- * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
deleted file mode 100644
--- a/third_party/rust/synom/src/helper.rs
+++ /dev/null
@@ -1,543 +0,0 @@
-use IResult;
-use space::{skip_whitespace, word_break};
-
-/// Parse a piece of punctuation like "+" or "+=".
-///
-/// See also `keyword!` for parsing keywords, which are subtly different from
-/// punctuation.
-///
-/// - **Syntax:** `punct!("...")`
-/// - **Output:** `&str`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// // Parse zero or more bangs.
-/// named!(many_bangs -> Vec<&str>,
-/// many0!(punct!("!"))
-/// );
-///
-/// fn main() {
-/// let input = "!! !";
-/// let parsed = many_bangs(input).expect("bangs");
-/// assert_eq!(parsed, ["!", "!", "!"]);
-/// }
-/// ```
-#[macro_export]
-macro_rules! punct {
- ($i:expr, $punct:expr) => {
- $crate::helper::punct($i, $punct)
- };
-}
-
-// Not public API.
-#[doc(hidden)]
-pub fn punct<'a>(input: &'a str, token: &'static str) -> IResult<&'a str, &'a str> {
- let input = skip_whitespace(input);
- if input.starts_with(token) {
- IResult::Done(&input[token.len()..], token)
- } else {
- IResult::Error
- }
-}
-
-/// Parse a keyword like "fn" or "struct".
-///
-/// See also `punct!` for parsing punctuation, which are subtly different from
-/// keywords.
-///
-/// - **Syntax:** `keyword!("...")`
-/// - **Output:** `&str`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use synom::IResult;
-///
-/// // Parse zero or more "bang" keywords.
-/// named!(many_bangs -> Vec<&str>,
-/// terminated!(
-/// many0!(keyword!("bang")),
-/// punct!(";")
-/// )
-/// );
-///
-/// fn main() {
-/// let input = "bang bang bang;";
-/// let parsed = many_bangs(input).expect("bangs");
-/// assert_eq!(parsed, ["bang", "bang", "bang"]);
-///
-/// let input = "bangbang;";
-/// let err = many_bangs(input);
-/// assert_eq!(err, IResult::Error);
-/// }
-/// ```
-#[macro_export]
-macro_rules! keyword {
- ($i:expr, $keyword:expr) => {
- $crate::helper::keyword($i, $keyword)
- };
-}
-
-// Not public API.
-#[doc(hidden)]
-pub fn keyword<'a>(input: &'a str, token: &'static str) -> IResult<&'a str, &'a str> {
- match punct(input, token) {
- IResult::Done(rest, _) => {
- match word_break(rest) {
- IResult::Done(_, _) => IResult::Done(rest, token),
- IResult::Error => IResult::Error,
- }
- }
- IResult::Error => IResult::Error,
- }
-}
-
-/// Turn a failed parse into `None` and a successful parse into `Some`.
-///
-/// - **Syntax:** `option!(THING)`
-/// - **Output:** `Option<THING>`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// named!(maybe_bang -> Option<&str>, option!(punct!("!")));
-///
-/// fn main() {
-/// let input = "!";
-/// let parsed = maybe_bang(input).expect("maybe bang");
-/// assert_eq!(parsed, Some("!"));
-///
-/// let input = "";
-/// let parsed = maybe_bang(input).expect("maybe bang");
-/// assert_eq!(parsed, None);
-/// }
-/// ```
-#[macro_export]
-macro_rules! option {
- ($i:expr, $submac:ident!( $($args:tt)* )) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Done(i, o) => $crate::IResult::Done(i, Some(o)),
- $crate::IResult::Error => $crate::IResult::Done($i, None),
- }
- };
-
- ($i:expr, $f:expr) => {
- option!($i, call!($f));
- };
-}
-
-/// Turn a failed parse into an empty vector. The argument parser must itself
-/// return a vector.
-///
-/// This is often more convenient than `option!(...)` when the argument produces
-/// a vector.
-///
-/// - **Syntax:** `opt_vec!(THING)`
-/// - **Output:** `THING`, which must be `Vec<T>`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::{Lifetime, Ty};
-/// use syn::parse::{lifetime, ty};
-///
-/// named!(bound_lifetimes -> (Vec<Lifetime>, Ty), tuple!(
-/// opt_vec!(do_parse!(
-/// keyword!("for") >>
-/// punct!("<") >>
-/// lifetimes: terminated_list!(punct!(","), lifetime) >>
-/// punct!(">") >>
-/// (lifetimes)
-/// )),
-/// ty
-/// ));
-///
-/// fn main() {
-/// let input = "for<'a, 'b> fn(&'a A) -> &'b B";
-/// let parsed = bound_lifetimes(input).expect("bound lifetimes");
-/// assert_eq!(parsed.0, [Lifetime::new("'a"), Lifetime::new("'b")]);
-/// println!("{:?}", parsed);
-///
-/// let input = "From<String>";
-/// let parsed = bound_lifetimes(input).expect("bound lifetimes");
-/// assert!(parsed.0.is_empty());
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! opt_vec {
- ($i:expr, $submac:ident!( $($args:tt)* )) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Done(i, o) => $crate::IResult::Done(i, o),
- $crate::IResult::Error => $crate::IResult::Done($i, Vec::new()),
- }
- };
-}
-
-/// Parses nothing and always succeeds.
-///
-/// This can be useful as a fallthrough case in `alt!`.
-///
-/// - **Syntax:** `epsilon!()`
-/// - **Output:** `()`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Mutability;
-///
-/// named!(mutability -> Mutability, alt!(
-/// keyword!("mut") => { |_| Mutability::Mutable }
-/// |
-/// epsilon!() => { |_| Mutability::Immutable }
-/// ));
-///
-/// fn main() {
-/// let input = "mut";
-/// let parsed = mutability(input).expect("mutability");
-/// assert_eq!(parsed, Mutability::Mutable);
-///
-/// let input = "";
-/// let parsed = mutability(input).expect("mutability");
-/// assert_eq!(parsed, Mutability::Immutable);
-/// }
-/// ```
-#[macro_export]
-macro_rules! epsilon {
- ($i:expr,) => {
- $crate::IResult::Done($i, ())
- };
-}
-
-/// Run a parser, binding the result to a name, and then evaluating an
-/// expression.
-///
-/// Discards the result of the expression and parser.
-///
-/// - **Syntax:** `tap!(NAME : THING => EXPR)`
-/// - **Output:** `()`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::{Expr, ExprKind};
-/// use syn::parse::expr;
-///
-/// named!(expr_with_arrow_call -> Expr, do_parse!(
-/// mut e: expr >>
-/// many0!(tap!(arg: tuple!(punct!("=>"), expr) => {
-/// e = Expr {
-/// node: ExprKind::Call(Box::new(e), vec![arg.1]),
-/// attrs: Vec::new(),
-/// };
-/// })) >>
-/// (e)
-/// ));
-///
-/// fn main() {
-/// let input = "something => argument1 => argument2";
-///
-/// let parsed = expr_with_arrow_call(input).expect("expr with arrow call");
-///
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[doc(hidden)]
-#[macro_export]
-macro_rules! tap {
- ($i:expr, $name:ident : $submac:ident!( $($args:tt)* ) => $e:expr) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Done(i, o) => {
- let $name = o;
- $e;
- $crate::IResult::Done(i, ())
- }
- $crate::IResult::Error => $crate::IResult::Error,
- }
- };
-
- ($i:expr, $name:ident : $f:expr => $e:expr) => {
- tap!($i, $name: call!($f) => $e);
- };
-}
-
-/// Zero or more values separated by some separator. Does not allow a trailing
-/// seperator.
-///
-/// - **Syntax:** `separated_list!(punct!("..."), THING)`
-/// - **Output:** `Vec<THING>`
-///
-/// You may also be looking for:
-///
-/// - `separated_nonempty_list!` - one or more values
-/// - `terminated_list!` - zero or more, allows trailing separator
-/// - `many0!` - zero or more, no separator
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Expr;
-/// use syn::parse::expr;
-///
-/// named!(expr_list -> Vec<Expr>,
-/// separated_list!(punct!(","), expr)
-/// );
-///
-/// fn main() {
-/// let input = "1 + 1, things, Construct { this: thing }";
-///
-/// let parsed = expr_list(input).expect("expr list");
-/// assert_eq!(parsed.len(), 3);
-/// }
-/// ```
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Ident;
-/// use syn::parse::ident;
-///
-/// named!(run_on -> Vec<Ident>,
-/// terminated!(
-/// separated_list!(keyword!("and"), preceded!(punct!("$"), ident)),
-/// punct!("...")
-/// )
-/// );
-///
-/// fn main() {
-/// let input = "$expr and $ident and $pat ...";
-///
-/// let parsed = run_on(input).expect("run-on sentence");
-/// assert_eq!(parsed.len(), 3);
-/// assert_eq!(parsed[0], "expr");
-/// assert_eq!(parsed[1], "ident");
-/// assert_eq!(parsed[2], "pat");
-/// }
-/// ```
-#[macro_export]
-macro_rules! separated_list {
- // Try to use this branch if possible - makes a difference in compile time.
- ($i:expr, punct!($sep:expr), $f:ident) => {
- $crate::helper::separated_list($i, $sep, $f, false)
- };
-
- ($i:expr, $sepmac:ident!( $($separgs:tt)* ), $fmac:ident!( $($fargs:tt)* )) => {{
- let mut res = ::std::vec::Vec::new();
- let mut input = $i;
-
- // get the first element
- match $fmac!(input, $($fargs)*) {
- $crate::IResult::Error => $crate::IResult::Done(input, res),
- $crate::IResult::Done(i, o) => {
- if i.len() == input.len() {
- $crate::IResult::Error
- } else {
- res.push(o);
- input = i;
-
- // get the separator first
- while let $crate::IResult::Done(i2, _) = $sepmac!(input, $($separgs)*) {
- if i2.len() == input.len() {
- break;
- }
-
- // get the element next
- if let $crate::IResult::Done(i3, o3) = $fmac!(i2, $($fargs)*) {
- if i3.len() == i2.len() {
- break;
- }
- res.push(o3);
- input = i3;
- } else {
- break;
- }
- }
- $crate::IResult::Done(input, res)
- }
- }
- }
- }};
-
- ($i:expr, $sepmac:ident!( $($separgs:tt)* ), $f:expr) => {
- separated_list!($i, $sepmac!($(separgs)*), call!($f))
- };
-
- ($i:expr, $sep:expr, $fmac:ident!( $($fargs:tt)* )) => {
- separated_list!($i, call!($sep), $fmac!($(fargs)*))
- };
-
- ($i:expr, $sep:expr, $f:expr) => {
- separated_list!($i, call!($sep), call!($f))
- };
-}
-
-/// Zero or more values separated by some separator. A trailing separator is
-/// allowed.
-///
-/// - **Syntax:** `terminated_list!(punct!("..."), THING)`
-/// - **Output:** `Vec<THING>`
-///
-/// You may also be looking for:
-///
-/// - `separated_list!` - zero or more, allows trailing separator
-/// - `separated_nonempty_list!` - one or more values
-/// - `many0!` - zero or more, no separator
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Expr;
-/// use syn::parse::expr;
-///
-/// named!(expr_list -> Vec<Expr>,
-/// terminated_list!(punct!(","), expr)
-/// );
-///
-/// fn main() {
-/// let input = "1 + 1, things, Construct { this: thing },";
-///
-/// let parsed = expr_list(input).expect("expr list");
-/// assert_eq!(parsed.len(), 3);
-/// }
-/// ```
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Ident;
-/// use syn::parse::ident;
-///
-/// named!(run_on -> Vec<Ident>,
-/// terminated!(
-/// terminated_list!(keyword!("and"), preceded!(punct!("$"), ident)),
-/// punct!("...")
-/// )
-/// );
-///
-/// fn main() {
-/// let input = "$expr and $ident and $pat and ...";
-///
-/// let parsed = run_on(input).expect("run-on sentence");
-/// assert_eq!(parsed.len(), 3);
-/// assert_eq!(parsed[0], "expr");
-/// assert_eq!(parsed[1], "ident");
-/// assert_eq!(parsed[2], "pat");
-/// }
-/// ```
-#[macro_export]
-macro_rules! terminated_list {
- // Try to use this branch if possible - makes a difference in compile time.
- ($i:expr, punct!($sep:expr), $f:ident) => {
- $crate::helper::separated_list($i, $sep, $f, true)
- };
-
- ($i:expr, $sepmac:ident!( $($separgs:tt)* ), $fmac:ident!( $($fargs:tt)* )) => {{
- let mut res = ::std::vec::Vec::new();
- let mut input = $i;
-
- // get the first element
- match $fmac!(input, $($fargs)*) {
- $crate::IResult::Error => $crate::IResult::Done(input, res),
- $crate::IResult::Done(i, o) => {
- if i.len() == input.len() {
- $crate::IResult::Error
- } else {
- res.push(o);
- input = i;
-
- // get the separator first
- while let $crate::IResult::Done(i2, _) = $sepmac!(input, $($separgs)*) {
- if i2.len() == input.len() {
- break;
- }
-
- // get the element next
- if let $crate::IResult::Done(i3, o3) = $fmac!(i2, $($fargs)*) {
- if i3.len() == i2.len() {
- break;
- }
- res.push(o3);
- input = i3;
- } else {
- break;
- }
- }
- if let $crate::IResult::Done(after, _) = $sepmac!(input, $($separgs)*) {
- input = after;
- }
- $crate::IResult::Done(input, res)
- }
- }
- }
- }};
-
- ($i:expr, $sepmac:ident!( $($separgs:tt)* ), $f:expr) => {
- terminated_list!($i, $sepmac!($(separgs)*), call!($f))
- };
-
- ($i:expr, $sep:expr, $fmac:ident!( $($fargs:tt)* )) => {
- terminated_list!($i, call!($sep), $fmac!($(fargs)*))
- };
-
- ($i:expr, $sep:expr, $f:expr) => {
- terminated_list!($i, call!($sep), call!($f))
- };
-}
-
-// Not public API.
-#[doc(hidden)]
-pub fn separated_list<'a, T>(mut input: &'a str,
- sep: &'static str,
- f: fn(&'a str) -> IResult<&'a str, T>,
- terminated: bool)
- -> IResult<&'a str, Vec<T>> {
- let mut res = Vec::new();
-
- // get the first element
- match f(input) {
- IResult::Error => IResult::Done(input, res),
- IResult::Done(i, o) => {
- if i.len() == input.len() {
- IResult::Error
- } else {
- res.push(o);
- input = i;
-
- // get the separator first
- while let IResult::Done(i2, _) = punct(input, sep) {
- if i2.len() == input.len() {
- break;
- }
-
- // get the element next
- if let IResult::Done(i3, o3) = f(i2) {
- if i3.len() == i2.len() {
- break;
- }
- res.push(o3);
- input = i3;
- } else {
- break;
- }
- }
- if terminated {
- if let IResult::Done(after, _) = punct(input, sep) {
- input = after;
- }
- }
- IResult::Done(input, res)
- }
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/synom/src/lib.rs
+++ /dev/null
@@ -1,1225 +0,0 @@
-//! Adapted from [`nom`](https://github.com/Geal/nom) by removing the
-//! `IResult::Incomplete` variant which:
-//!
-//! - we don't need,
-//! - is an unintuitive footgun when working with non-streaming use cases, and
-//! - more than doubles compilation time.
-//!
-//! ## Whitespace handling strategy
-//!
-//! As (sy)nom is a parser combinator library, the parsers provided here and
-//! that you implement yourself are all made up of successively more primitive
-//! parsers, eventually culminating in a small number of fundamental parsers
-//! that are implemented in Rust. Among these are `punct!` and `keyword!`.
-//!
-//! All synom fundamental parsers (those not combined out of other parsers)
-//! should be written to skip over leading whitespace in their input. This way,
-//! as long as every parser eventually boils down to some combination of
-//! fundamental parsers, we get correct whitespace handling at all levels for
-//! free.
-//!
-//! For our use case, this strategy is a huge improvement in usability,
-//! correctness, and compile time over nom's `ws!` strategy.
-
-extern crate unicode_xid;
-
-#[doc(hidden)]
-pub mod space;
-
-#[doc(hidden)]
-pub mod helper;
-
-/// The result of a parser.
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum IResult<I, O> {
- /// Parsing succeeded. The first field contains the rest of the unparsed
- /// data and the second field contains the parse result.
- Done(I, O),
- /// Parsing failed.
- Error,
-}
-
-impl<'a, O> IResult<&'a str, O> {
- /// Unwraps the result, asserting the the parse is complete. Panics with a
- /// message based on the given string if the parse failed or is incomplete.
- ///
- /// ```rust
- /// extern crate syn;
- /// #[macro_use] extern crate synom;
- ///
- /// use syn::Ty;
- /// use syn::parse::ty;
- ///
- /// // One or more Rust types separated by commas.
- /// named!(comma_separated_types -> Vec<Ty>,
- /// separated_nonempty_list!(punct!(","), ty)
- /// );
- ///
- /// fn main() {
- /// let input = "&str, Map<K, V>, String";
- ///
- /// let parsed = comma_separated_types(input).expect("comma-separated types");
- ///
- /// assert_eq!(parsed.len(), 3);
- /// println!("{:?}", parsed);
- /// }
- /// ```
- pub fn expect(self, name: &str) -> O {
- match self {
- IResult::Done(mut rest, o) => {
- rest = space::skip_whitespace(rest);
- if rest.is_empty() {
- o
- } else {
- panic!("unparsed tokens after {}: {:?}", name, rest)
- }
- }
- IResult::Error => panic!("failed to parse {}", name),
- }
- }
-}
-
-/// Define a function from a parser combination.
-///
-/// - **Syntax:** `named!(NAME -> TYPE, PARSER)` or `named!(pub NAME -> TYPE, PARSER)`
-///
-/// ```rust
-/// # extern crate syn;
-/// # #[macro_use] extern crate synom;
-/// # use syn::Ty;
-/// # use syn::parse::ty;
-/// // One or more Rust types separated by commas.
-/// named!(pub comma_separated_types -> Vec<Ty>,
-/// separated_nonempty_list!(punct!(","), ty)
-/// );
-/// # fn main() {}
-/// ```
-#[macro_export]
-macro_rules! named {
- ($name:ident -> $o:ty, $submac:ident!( $($args:tt)* )) => {
- fn $name(i: &str) -> $crate::IResult<&str, $o> {
- $submac!(i, $($args)*)
- }
- };
-
- (pub $name:ident -> $o:ty, $submac:ident!( $($args:tt)* )) => {
- pub fn $name(i: &str) -> $crate::IResult<&str, $o> {
- $submac!(i, $($args)*)
- }
- };
-}
-
-/// Invoke the given parser function with the passed in arguments.
-///
-/// - **Syntax:** `call!(FUNCTION, ARGS...)`
-///
-/// where the signature of the function is `fn(&str, ARGS...) -> IResult<&str, T>`
-/// - **Output:** `T`, the result of invoking the function `FUNCTION`
-///
-/// ```rust
-/// #[macro_use] extern crate synom;
-///
-/// use synom::IResult;
-///
-/// // Parses any string up to but not including the given character, returning
-/// // the content up to the given character. The given character is required to
-/// // be present in the input string.
-/// fn skip_until(input: &str, ch: char) -> IResult<&str, &str> {
-/// if let Some(pos) = input.find(ch) {
-/// IResult::Done(&input[pos..], &input[..pos])
-/// } else {
-/// IResult::Error
-/// }
-/// }
-///
-/// // Parses any string surrounded by tilde characters '~'. Returns the content
-/// // between the tilde characters.
-/// named!(surrounded_by_tilde -> &str, delimited!(
-/// punct!("~"),
-/// call!(skip_until, '~'),
-/// punct!("~")
-/// ));
-///
-/// fn main() {
-/// let input = "~ abc def ~";
-///
-/// let inner = surrounded_by_tilde(input).expect("surrounded by tilde");
-///
-/// println!("{:?}", inner);
-/// }
-/// ```
-#[macro_export]
-macro_rules! call {
- ($i:expr, $fun:expr $(, $args:expr)*) => {
- $fun($i $(, $args)*)
- };
-}
-
-/// Transform the result of a parser by applying a function or closure.
-///
-/// - **Syntax:** `map!(THING, FN)`
-/// - **Output:** the return type of function FN applied to THING
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::{Item, Ident};
-/// use syn::parse::item;
-///
-/// fn get_item_ident(item: Item) -> Ident {
-/// item.ident
-/// }
-///
-/// // Parses an item and returns the name (identifier) of the item only.
-/// named!(item_ident -> Ident,
-/// map!(item, get_item_ident)
-/// );
-///
-/// // Or equivalently:
-/// named!(item_ident2 -> Ident,
-/// map!(item, |i: Item| i.ident)
-/// );
-///
-/// fn main() {
-/// let input = "fn foo() {}";
-///
-/// let parsed = item_ident(input).expect("item");
-///
-/// assert_eq!(parsed, "foo");
-/// }
-/// ```
-#[macro_export]
-macro_rules! map {
- ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) => {
- $crate::IResult::Done(i, call!(o, $g))
- }
- }
- };
-
- ($i:expr, $f:expr, $g:expr) => {
- map!($i, call!($f), $g)
- };
-}
-
-/// Parses successfully if the given parser fails to parse. Does not consume any
-/// of the input.
-///
-/// - **Syntax:** `not!(THING)`
-/// - **Output:** `()`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-/// use synom::IResult;
-///
-/// // Parses a shebang line like `#!/bin/bash` and returns the part after `#!`.
-/// // Note that a line starting with `#![` is an inner attribute, not a
-/// // shebang.
-/// named!(shebang -> &str, preceded!(
-/// tuple!(tag!("#!"), not!(tag!("["))),
-/// take_until!("\n")
-/// ));
-///
-/// fn main() {
-/// let bin_bash = "#!/bin/bash\n";
-/// let parsed = shebang(bin_bash).expect("shebang");
-/// assert_eq!(parsed, "/bin/bash");
-///
-/// let inner_attr = "#![feature(specialization)]\n";
-/// let err = shebang(inner_attr);
-/// assert_eq!(err, IResult::Error);
-/// }
-/// ```
-#[macro_export]
-macro_rules! not {
- ($i:expr, $submac:ident!( $($args:tt)* )) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Done(_, _) => $crate::IResult::Error,
- $crate::IResult::Error => $crate::IResult::Done($i, ()),
- }
- };
-}
-
-/// Conditionally execute the given parser.
-///
-/// If you are familiar with nom, this is nom's `cond_with_error` parser.
-///
-/// - **Syntax:** `cond!(CONDITION, THING)`
-/// - **Output:** `Some(THING)` if the condition is true, else `None`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::parse::boolean;
-///
-/// // Parses a tuple of booleans like `(true, false, false)`, possibly with a
-/// // dotdot indicating omitted values like `(true, true, .., true)`. Returns
-/// // separate vectors for the booleans before and after the dotdot. The second
-/// // vector is None if there was no dotdot.
-/// named!(bools_with_dotdot -> (Vec<bool>, Option<Vec<bool>>), do_parse!(
-/// punct!("(") >>
-/// before: separated_list!(punct!(","), boolean) >>
-/// after: option!(do_parse!(
-/// // Only allow comma if there are elements before dotdot, i.e. cannot
-/// // be `(, .., true)`.
-/// cond!(!before.is_empty(), punct!(",")) >>
-/// punct!("..") >>
-/// after: many0!(preceded!(punct!(","), boolean)) >>
-/// // Only allow trailing comma if there are elements after dotdot,
-/// // i.e. cannot be `(true, .., )`.
-/// cond!(!after.is_empty(), option!(punct!(","))) >>
-/// (after)
-/// )) >>
-/// // Allow trailing comma if there is no dotdot but there are elements.
-/// cond!(!before.is_empty() && after.is_none(), option!(punct!(","))) >>
-/// punct!(")") >>
-/// (before, after)
-/// ));
-///
-/// fn main() {
-/// let input = "(true, false, false)";
-/// let parsed = bools_with_dotdot(input).expect("bools with dotdot");
-/// assert_eq!(parsed, (vec![true, false, false], None));
-///
-/// let input = "(true, true, .., true)";
-/// let parsed = bools_with_dotdot(input).expect("bools with dotdot");
-/// assert_eq!(parsed, (vec![true, true], Some(vec![true])));
-///
-/// let input = "(.., true)";
-/// let parsed = bools_with_dotdot(input).expect("bools with dotdot");
-/// assert_eq!(parsed, (vec![], Some(vec![true])));
-///
-/// let input = "(true, true, ..)";
-/// let parsed = bools_with_dotdot(input).expect("bools with dotdot");
-/// assert_eq!(parsed, (vec![true, true], Some(vec![])));
-///
-/// let input = "(..)";
-/// let parsed = bools_with_dotdot(input).expect("bools with dotdot");
-/// assert_eq!(parsed, (vec![], Some(vec![])));
-/// }
-/// ```
-#[macro_export]
-macro_rules! cond {
- ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => {
- if $cond {
- match $submac!($i, $($args)*) {
- $crate::IResult::Done(i, o) => $crate::IResult::Done(i, ::std::option::Option::Some(o)),
- $crate::IResult::Error => $crate::IResult::Error,
- }
- } else {
- $crate::IResult::Done($i, ::std::option::Option::None)
- }
- };
-
- ($i:expr, $cond:expr, $f:expr) => {
- cond!($i, $cond, call!($f))
- };
-}
-
-/// Fail to parse if condition is false, otherwise parse the given parser.
-///
-/// This is typically used inside of `option!` or `alt!`.
-///
-/// - **Syntax:** `cond_reduce!(CONDITION, THING)`
-/// - **Output:** `THING`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::parse::boolean;
-///
-/// #[derive(Debug, PartialEq)]
-/// struct VariadicBools {
-/// data: Vec<bool>,
-/// variadic: bool,
-/// }
-///
-/// // Parse one or more comma-separated booleans, possibly ending in "..." to
-/// // indicate there may be more.
-/// named!(variadic_bools -> VariadicBools, do_parse!(
-/// data: separated_nonempty_list!(punct!(","), boolean) >>
-/// trailing_comma: option!(punct!(",")) >>
-/// // Only allow "..." if there is a comma after the last boolean. Using
-/// // `cond_reduce!` is more convenient here than using `cond!`. The
-/// // alternatives are:
-/// //
-/// // - `cond!(c, option!(p))` or `option!(cond!(c, p))`
-/// // Gives `Some(Some("..."))` for variadic and `Some(None)` or `None`
-/// // which both mean not variadic.
-/// // - `cond_reduce!(c, option!(p))`
-/// // Incorrect; would fail to parse if there is no trailing comma.
-/// // - `option!(cond_reduce!(c, p))`
-/// // Gives `Some("...")` for variadic and `None` otherwise. Perfect!
-/// variadic: option!(cond_reduce!(trailing_comma.is_some(), punct!("..."))) >>
-/// (VariadicBools {
-/// data: data,
-/// variadic: variadic.is_some(),
-/// })
-/// ));
-///
-/// fn main() {
-/// let input = "true, true";
-/// let parsed = variadic_bools(input).expect("variadic bools");
-/// assert_eq!(parsed, VariadicBools {
-/// data: vec![true, true],
-/// variadic: false,
-/// });
-///
-/// let input = "true, ...";
-/// let parsed = variadic_bools(input).expect("variadic bools");
-/// assert_eq!(parsed, VariadicBools {
-/// data: vec![true],
-/// variadic: true,
-/// });
-/// }
-/// ```
-#[macro_export]
-macro_rules! cond_reduce {
- ($i:expr, $cond:expr, $submac:ident!( $($args:tt)* )) => {
- if $cond {
- $submac!($i, $($args)*)
- } else {
- $crate::IResult::Error
- }
- };
-
- ($i:expr, $cond:expr, $f:expr) => {
- cond_reduce!($i, $cond, call!($f))
- };
-}
-
-/// Parse two things, returning the value of the second.
-///
-/// - **Syntax:** `preceded!(BEFORE, THING)`
-/// - **Output:** `THING`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Expr;
-/// use syn::parse::expr;
-///
-/// // An expression preceded by ##.
-/// named!(pound_pound_expr -> Expr,
-/// preceded!(punct!("##"), expr)
-/// );
-///
-/// fn main() {
-/// let input = "## 1 + 1";
-///
-/// let parsed = pound_pound_expr(input).expect("pound pound expr");
-///
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! preceded {
- ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => {
- match tuple!($i, $submac!($($args)*), $submac2!($($args2)*)) {
- $crate::IResult::Done(remaining, (_, o)) => $crate::IResult::Done(remaining, o),
- $crate::IResult::Error => $crate::IResult::Error,
- }
- };
-
- ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
- preceded!($i, $submac!($($args)*), call!($g))
- };
-
- ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => {
- preceded!($i, call!($f), $submac!($($args)*))
- };
-
- ($i:expr, $f:expr, $g:expr) => {
- preceded!($i, call!($f), call!($g))
- };
-}
-
-/// Parse two things, returning the value of the first.
-///
-/// - **Syntax:** `terminated!(THING, AFTER)`
-/// - **Output:** `THING`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Expr;
-/// use syn::parse::expr;
-///
-/// // An expression terminated by ##.
-/// named!(expr_pound_pound -> Expr,
-/// terminated!(expr, punct!("##"))
-/// );
-///
-/// fn main() {
-/// let input = "1 + 1 ##";
-///
-/// let parsed = expr_pound_pound(input).expect("expr pound pound");
-///
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! terminated {
- ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => {
- match tuple!($i, $submac!($($args)*), $submac2!($($args2)*)) {
- $crate::IResult::Done(remaining, (o, _)) => $crate::IResult::Done(remaining, o),
- $crate::IResult::Error => $crate::IResult::Error,
- }
- };
-
- ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
- terminated!($i, $submac!($($args)*), call!($g))
- };
-
- ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => {
- terminated!($i, call!($f), $submac!($($args)*))
- };
-
- ($i:expr, $f:expr, $g:expr) => {
- terminated!($i, call!($f), call!($g))
- };
-}
-
-/// Parse zero or more values using the given parser.
-///
-/// - **Syntax:** `many0!(THING)`
-/// - **Output:** `Vec<THING>`
-///
-/// You may also be looking for:
-///
-/// - `separated_list!` - zero or more values with separator
-/// - `separated_nonempty_list!` - one or more values
-/// - `terminated_list!` - zero or more, allows trailing separator
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Item;
-/// use syn::parse::item;
-///
-/// named!(items -> Vec<Item>, many0!(item));
-///
-/// fn main() {
-/// let input = "
-/// fn a() {}
-/// fn b() {}
-/// ";
-///
-/// let parsed = items(input).expect("items");
-///
-/// assert_eq!(parsed.len(), 2);
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! many0 {
- ($i:expr, $submac:ident!( $($args:tt)* )) => {{
- let ret;
- let mut res = ::std::vec::Vec::new();
- let mut input = $i;
-
- loop {
- if input.is_empty() {
- ret = $crate::IResult::Done(input, res);
- break;
- }
-
- match $submac!(input, $($args)*) {
- $crate::IResult::Error => {
- ret = $crate::IResult::Done(input, res);
- break;
- }
- $crate::IResult::Done(i, o) => {
- // loop trip must always consume (otherwise infinite loops)
- if i.len() == input.len() {
- ret = $crate::IResult::Error;
- break;
- }
-
- res.push(o);
- input = i;
- }
- }
- }
-
- ret
- }};
-
- ($i:expr, $f:expr) => {
- $crate::many0($i, $f)
- };
-}
-
-// Improve compile time by compiling this loop only once per type it is used
-// with.
-//
-// Not public API.
-#[doc(hidden)]
-pub fn many0<'a, T>(mut input: &'a str,
- f: fn(&'a str) -> IResult<&'a str, T>)
- -> IResult<&'a str, Vec<T>> {
- let mut res = Vec::new();
-
- loop {
- if input.is_empty() {
- return IResult::Done(input, res);
- }
-
- match f(input) {
- IResult::Error => {
- return IResult::Done(input, res);
- }
- IResult::Done(i, o) => {
- // loop trip must always consume (otherwise infinite loops)
- if i.len() == input.len() {
- return IResult::Error;
- }
-
- res.push(o);
- input = i;
- }
- }
- }
-}
-
-/// Parse a value without consuming it from the input data.
-///
-/// - **Syntax:** `peek!(THING)`
-/// - **Output:** `THING`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Expr;
-/// use syn::parse::{ident, expr};
-/// use synom::IResult;
-///
-/// // Parse an expression that begins with an identifier.
-/// named!(ident_expr -> Expr,
-/// preceded!(peek!(ident), expr)
-/// );
-///
-/// fn main() {
-/// // begins with an identifier
-/// let input = "banana + 1";
-/// let parsed = ident_expr(input).expect("ident");
-/// println!("{:?}", parsed);
-///
-/// // does not begin with an identifier
-/// let input = "1 + banana";
-/// let err = ident_expr(input);
-/// assert_eq!(err, IResult::Error);
-/// }
-/// ```
-#[macro_export]
-macro_rules! peek {
- ($i:expr, $submac:ident!( $($args:tt)* )) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Done(_, o) => $crate::IResult::Done($i, o),
- $crate::IResult::Error => $crate::IResult::Error,
- }
- };
-
- ($i:expr, $f:expr) => {
- peek!($i, call!($f))
- };
-}
-
-/// Parse the part of the input up to but not including the given string. Fail
-/// to parse if the given string is not present in the input.
-///
-/// - **Syntax:** `take_until!("...")`
-/// - **Output:** `&str`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-/// use synom::IResult;
-///
-/// // Parse a single line doc comment: /// ...
-/// named!(single_line_doc -> &str,
-/// preceded!(punct!("///"), take_until!("\n"))
-/// );
-///
-/// fn main() {
-/// let comment = "/// comment\n";
-/// let parsed = single_line_doc(comment).expect("single line doc comment");
-/// assert_eq!(parsed, " comment");
-/// }
-/// ```
-#[macro_export]
-macro_rules! take_until {
- ($i:expr, $substr:expr) => {{
- if $substr.len() > $i.len() {
- $crate::IResult::Error
- } else {
- let substr_vec: Vec<char> = $substr.chars().collect();
- let mut window: Vec<char> = vec![];
- let mut offset = $i.len();
- let mut parsed = false;
- for (o, c) in $i.char_indices() {
- window.push(c);
- if window.len() > substr_vec.len() {
- window.remove(0);
- }
- if window == substr_vec {
- parsed = true;
- window.pop();
- let window_len: usize = window.iter()
- .map(|x| x.len_utf8())
- .fold(0, |x, y| x + y);
- offset = o - window_len;
- break;
- }
- }
- if parsed {
- $crate::IResult::Done(&$i[offset..], &$i[..offset])
- } else {
- $crate::IResult::Error
- }
- }
- }};
-}
-
-/// Parse the given string from exactly the current position in the input. You
-/// almost always want `punct!` or `keyword!` instead of this.
-///
-/// The `tag!` parser is equivalent to `punct!` but does not ignore leading
-/// whitespace. Both `punct!` and `keyword!` skip over leading whitespace. See
-/// an explanation of synom's whitespace handling strategy in the top-level
-/// crate documentation.
-///
-/// - **Syntax:** `tag!("...")`
-/// - **Output:** `"..."`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::StrLit;
-/// use syn::parse::string;
-/// use synom::IResult;
-///
-/// // Parse a proposed syntax for an owned string literal: "abc"s
-/// named!(owned_string -> String,
-/// map!(
-/// terminated!(string, tag!("s")),
-/// |lit: StrLit| lit.value
-/// )
-/// );
-///
-/// fn main() {
-/// let input = r#" "abc"s "#;
-/// let parsed = owned_string(input).expect("owned string literal");
-/// println!("{:?}", parsed);
-///
-/// let input = r#" "abc" s "#;
-/// let err = owned_string(input);
-/// assert_eq!(err, IResult::Error);
-/// }
-/// ```
-#[macro_export]
-macro_rules! tag {
- ($i:expr, $tag:expr) => {
- if $i.starts_with($tag) {
- $crate::IResult::Done(&$i[$tag.len()..], &$i[..$tag.len()])
- } else {
- $crate::IResult::Error
- }
- };
-}
-
-/// Pattern-match the result of a parser to select which other parser to run.
-///
-/// - **Syntax:** `switch!(TARGET, PAT1 => THEN1 | PAT2 => THEN2 | ...)`
-/// - **Output:** `T`, the return type of `THEN1` and `THEN2` and ...
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::{Ident, Ty};
-/// use syn::parse::{ident, ty};
-///
-/// #[derive(Debug)]
-/// enum UnitType {
-/// Struct {
-/// name: Ident,
-/// },
-/// Enum {
-/// name: Ident,
-/// variant: Ident,
-/// },
-/// }
-///
-/// // Parse a unit struct or enum: either `struct S;` or `enum E { V }`.
-/// named!(unit_type -> UnitType, do_parse!(
-/// which: alt!(keyword!("struct") | keyword!("enum")) >>
-/// id: ident >>
-/// item: switch!(value!(which),
-/// "struct" => map!(
-/// punct!(";"),
-/// move |_| UnitType::Struct {
-/// name: id,
-/// }
-/// )
-/// |
-/// "enum" => map!(
-/// delimited!(punct!("{"), ident, punct!("}")),
-/// move |variant| UnitType::Enum {
-/// name: id,
-/// variant: variant,
-/// }
-/// )
-/// ) >>
-/// (item)
-/// ));
-///
-/// fn main() {
-/// let input = "struct S;";
-/// let parsed = unit_type(input).expect("unit struct or enum");
-/// println!("{:?}", parsed);
-///
-/// let input = "enum E { V }";
-/// let parsed = unit_type(input).expect("unit struct or enum");
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! switch {
- ($i:expr, $submac:ident!( $($args:tt)* ), $($p:pat => $subrule:ident!( $($args2:tt)* ))|* ) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) => match o {
- $(
- $p => $subrule!(i, $($args2)*),
- )*
- _ => $crate::IResult::Error,
- }
- }
- };
-}
-
-/// Produce the given value without parsing anything. Useful as an argument to
-/// `switch!`.
-///
-/// - **Syntax:** `value!(VALUE)`
-/// - **Output:** `VALUE`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::{Ident, Ty};
-/// use syn::parse::{ident, ty};
-///
-/// #[derive(Debug)]
-/// enum UnitType {
-/// Struct {
-/// name: Ident,
-/// },
-/// Enum {
-/// name: Ident,
-/// variant: Ident,
-/// },
-/// }
-///
-/// // Parse a unit struct or enum: either `struct S;` or `enum E { V }`.
-/// named!(unit_type -> UnitType, do_parse!(
-/// which: alt!(keyword!("struct") | keyword!("enum")) >>
-/// id: ident >>
-/// item: switch!(value!(which),
-/// "struct" => map!(
-/// punct!(";"),
-/// move |_| UnitType::Struct {
-/// name: id,
-/// }
-/// )
-/// |
-/// "enum" => map!(
-/// delimited!(punct!("{"), ident, punct!("}")),
-/// move |variant| UnitType::Enum {
-/// name: id,
-/// variant: variant,
-/// }
-/// )
-/// ) >>
-/// (item)
-/// ));
-///
-/// fn main() {
-/// let input = "struct S;";
-/// let parsed = unit_type(input).expect("unit struct or enum");
-/// println!("{:?}", parsed);
-///
-/// let input = "enum E { V }";
-/// let parsed = unit_type(input).expect("unit struct or enum");
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! value {
- ($i:expr, $res:expr) => {
- $crate::IResult::Done($i, $res)
- };
-}
-
-/// Value surrounded by a pair of delimiters.
-///
-/// - **Syntax:** `delimited!(OPEN, THING, CLOSE)`
-/// - **Output:** `THING`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Expr;
-/// use syn::parse::expr;
-///
-/// // An expression surrounded by [[ ... ]].
-/// named!(double_bracket_expr -> Expr,
-/// delimited!(punct!("[["), expr, punct!("]]"))
-/// );
-///
-/// fn main() {
-/// let input = "[[ 1 + 1 ]]";
-///
-/// let parsed = double_bracket_expr(input).expect("double bracket expr");
-///
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! delimited {
- ($i:expr, $submac:ident!( $($args:tt)* ), $($rest:tt)+) => {
- match tuple_parser!($i, (), $submac!($($args)*), $($rest)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i1, (_, o, _)) => $crate::IResult::Done(i1, o)
- }
- };
-
- ($i:expr, $f:expr, $($rest:tt)+) => {
- delimited!($i, call!($f), $($rest)*)
- };
-}
-
-/// One or more values separated by some separator. Does not allow a trailing
-/// separator.
-///
-/// - **Syntax:** `separated_nonempty_list!(SEPARATOR, THING)`
-/// - **Output:** `Vec<THING>`
-///
-/// You may also be looking for:
-///
-/// - `separated_list!` - one or more values
-/// - `terminated_list!` - zero or more, allows trailing separator
-/// - `many0!` - zero or more, no separator
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Ty;
-/// use syn::parse::ty;
-///
-/// // One or more Rust types separated by commas.
-/// named!(comma_separated_types -> Vec<Ty>,
-/// separated_nonempty_list!(punct!(","), ty)
-/// );
-///
-/// fn main() {
-/// let input = "&str, Map<K, V>, String";
-///
-/// let parsed = comma_separated_types(input).expect("comma-separated types");
-///
-/// assert_eq!(parsed.len(), 3);
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! separated_nonempty_list {
- ($i:expr, $sep:ident!( $($args:tt)* ), $submac:ident!( $($args2:tt)* )) => {{
- let mut res = ::std::vec::Vec::new();
- let mut input = $i;
-
- // get the first element
- match $submac!(input, $($args2)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) => {
- if i.len() == input.len() {
- $crate::IResult::Error
- } else {
- res.push(o);
- input = i;
-
- while let $crate::IResult::Done(i2, _) = $sep!(input, $($args)*) {
- if i2.len() == input.len() {
- break;
- }
-
- if let $crate::IResult::Done(i3, o3) = $submac!(i2, $($args2)*) {
- if i3.len() == i2.len() {
- break;
- }
- res.push(o3);
- input = i3;
- } else {
- break;
- }
- }
- $crate::IResult::Done(input, res)
- }
- }
- }
- }};
-
- ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
- separated_nonempty_list!($i, $submac!($($args)*), call!($g))
- };
-
- ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => {
- separated_nonempty_list!($i, call!($f), $submac!($($args)*))
- };
-
- ($i:expr, $f:expr, $g:expr) => {
- separated_nonempty_list!($i, call!($f), call!($g))
- };
-}
-
-/// Run a series of parsers and produce all of the results in a tuple.
-///
-/// - **Syntax:** `tuple!(A, B, C, ...)`
-/// - **Output:** `(A, B, C, ...)`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Ty;
-/// use syn::parse::ty;
-///
-/// named!(two_types -> (Ty, Ty), tuple!(ty, ty));
-///
-/// fn main() {
-/// let input = "&str Map<K, V>";
-///
-/// let parsed = two_types(input).expect("two types");
-///
-/// println!("{:?}", parsed);
-/// }
-/// ```
-#[macro_export]
-macro_rules! tuple {
- ($i:expr, $($rest:tt)*) => {
- tuple_parser!($i, (), $($rest)*)
- };
-}
-
-/// Internal parser, do not use directly.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! tuple_parser {
- ($i:expr, ($($parsed:tt),*), $e:ident, $($rest:tt)*) => {
- tuple_parser!($i, ($($parsed),*), call!($e), $($rest)*)
- };
-
- ($i:expr, (), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) =>
- tuple_parser!(i, (o), $($rest)*),
- }
- };
-
- ($i:expr, ($($parsed:tt)*), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) =>
- tuple_parser!(i, ($($parsed)* , o), $($rest)*),
- }
- };
-
- ($i:expr, ($($parsed:tt),*), $e:ident) => {
- tuple_parser!($i, ($($parsed),*), call!($e))
- };
-
- ($i:expr, (), $submac:ident!( $($args:tt)* )) => {
- $submac!($i, $($args)*)
- };
-
- ($i:expr, ($($parsed:expr),*), $submac:ident!( $($args:tt)* )) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) => $crate::IResult::Done(i, ($($parsed),*, o))
- }
- };
-
- ($i:expr, ($($parsed:expr),*)) => {
- $crate::IResult::Done($i, ($($parsed),*))
- };
-}
-
-/// Run a series of parsers, returning the result of the first one which
-/// succeeds.
-///
-/// Optionally allows for the result to be transformed.
-///
-/// - **Syntax:** `alt!(THING1 | THING2 => { FUNC } | ...)`
-/// - **Output:** `T`, the return type of `THING1` and `FUNC(THING2)` and ...
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::Ident;
-/// use syn::parse::ident;
-///
-/// named!(ident_or_bang -> Ident,
-/// alt!(
-/// ident
-/// |
-/// punct!("!") => { |_| "BANG".into() }
-/// )
-/// );
-///
-/// fn main() {
-/// let input = "foo";
-/// let parsed = ident_or_bang(input).expect("identifier or `!`");
-/// assert_eq!(parsed, "foo");
-///
-/// let input = "!";
-/// let parsed = ident_or_bang(input).expect("identifier or `!`");
-/// assert_eq!(parsed, "BANG");
-/// }
-/// ```
-#[macro_export]
-macro_rules! alt {
- ($i:expr, $e:ident | $($rest:tt)*) => {
- alt!($i, call!($e) | $($rest)*)
- };
-
- ($i:expr, $subrule:ident!( $($args:tt)*) | $($rest:tt)*) => {
- match $subrule!($i, $($args)*) {
- res @ $crate::IResult::Done(_, _) => res,
- _ => alt!($i, $($rest)*)
- }
- };
-
- ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr } | $($rest:tt)+) => {
- match $subrule!($i, $($args)*) {
- $crate::IResult::Done(i, o) => $crate::IResult::Done(i, $gen(o)),
- $crate::IResult::Error => alt!($i, $($rest)*)
- }
- };
-
- ($i:expr, $e:ident => { $gen:expr } | $($rest:tt)*) => {
- alt!($i, call!($e) => { $gen } | $($rest)*)
- };
-
- ($i:expr, $e:ident => { $gen:expr }) => {
- alt!($i, call!($e) => { $gen })
- };
-
- ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr }) => {
- match $subrule!($i, $($args)*) {
- $crate::IResult::Done(i, o) => $crate::IResult::Done(i, $gen(o)),
- $crate::IResult::Error => $crate::IResult::Error,
- }
- };
-
- ($i:expr, $e:ident) => {
- alt!($i, call!($e))
- };
-
- ($i:expr, $subrule:ident!( $($args:tt)*)) => {
- $subrule!($i, $($args)*)
- };
-}
-
-/// Run a series of parsers, one after another, optionally assigning the results
-/// a name. Fail if any of the parsers fails.
-///
-/// Produces the result of evaluating the final expression in parentheses with
-/// all of the previously named results bound.
-///
-/// - **Syntax:** `do_parse!(name: THING1 >> THING2 >> (RESULT))`
-/// - **Output:** `RESULT`
-///
-/// ```rust
-/// extern crate syn;
-/// #[macro_use] extern crate synom;
-///
-/// use syn::{Ident, TokenTree};
-/// use syn::parse::{ident, tt};
-///
-/// // Parse a macro invocation like `stringify!($args)`.
-/// named!(simple_mac -> (Ident, TokenTree), do_parse!(
-/// name: ident >>
-/// punct!("!") >>
-/// body: tt >>
-/// (name, body)
-/// ));
-///
-/// fn main() {
-/// let input = "stringify!($args)";
-/// let (name, body) = simple_mac(input).expect("macro invocation");
-/// println!("{:?}", name);
-/// println!("{:?}", body);
-/// }
-/// ```
-#[macro_export]
-macro_rules! do_parse {
- ($i:expr, ( $($rest:expr),* )) => {
- $crate::IResult::Done($i, ( $($rest),* ))
- };
-
- ($i:expr, $e:ident >> $($rest:tt)*) => {
- do_parse!($i, call!($e) >> $($rest)*)
- };
-
- ($i:expr, $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, _) =>
- do_parse!(i, $($rest)*),
- }
- };
-
- ($i:expr, $field:ident : $e:ident >> $($rest:tt)*) => {
- do_parse!($i, $field: call!($e) >> $($rest)*)
- };
-
- ($i:expr, $field:ident : $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) => {
- let $field = o;
- do_parse!(i, $($rest)*)
- },
- }
- };
-
- ($i:expr, mut $field:ident : $e:ident >> $($rest:tt)*) => {
- do_parse!($i, mut $field: call!($e) >> $($rest)*)
- };
-
- ($i:expr, mut $field:ident : $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
- match $submac!($i, $($args)*) {
- $crate::IResult::Error => $crate::IResult::Error,
- $crate::IResult::Done(i, o) => {
- let mut $field = o;
- do_parse!(i, $($rest)*)
- },
- }
- };
-}
deleted file mode 100644
--- a/third_party/rust/synom/src/space.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use IResult;
-use unicode_xid::UnicodeXID;
-
-pub fn whitespace(input: &str) -> IResult<&str, ()> {
- if input.is_empty() {
- return IResult::Error;
- }
-
- let bytes = input.as_bytes();
- let mut i = 0;
- while i < bytes.len() {
- let s = &input[i..];
- if bytes[i] == b'/' {
- if s.starts_with("//") && (!s.starts_with("///") || s.starts_with("////")) &&
- !s.starts_with("//!") {
- if let Some(len) = s.find('\n') {
- i += len + 1;
- continue;
- }
- break;
- } else if s.starts_with("/*") && (!s.starts_with("/**") || s.starts_with("/***")) &&
- !s.starts_with("/*!") {
- match block_comment(s) {
- IResult::Done(_, com) => {
- i += com.len();
- continue;
- }
- IResult::Error => {
- return IResult::Error;
- }
- }
- }
- }
- match bytes[i] {
- b' ' | 0x09...0x0d => {
- i += 1;
- continue;
- }
- b if b <= 0x7f => {}
- _ => {
- let ch = s.chars().next().unwrap();
- if is_whitespace(ch) {
- i += ch.len_utf8();
- continue;
- }
- }
- }
- return if i > 0 {
- IResult::Done(s, ())
- } else {
- IResult::Error
- };
- }
- IResult::Done("", ())
-}
-
-pub fn block_comment(input: &str) -> IResult<&str, &str> {
- if !input.starts_with("/*") {
- return IResult::Error;
- }
-
- let mut depth = 0;
- let bytes = input.as_bytes();
- let mut i = 0;
- let upper = bytes.len() - 1;
- while i < upper {
- if bytes[i] == b'/' && bytes[i + 1] == b'*' {
- depth += 1;
- i += 1; // eat '*'
- } else if bytes[i] == b'*' && bytes[i + 1] == b'/' {
- depth -= 1;
- if depth == 0 {
- return IResult::Done(&input[i + 2..], &input[..i + 2]);
- }
- i += 1; // eat '/'
- }
- i += 1;
- }
- IResult::Error
-}
-
-pub fn word_break(input: &str) -> IResult<&str, ()> {
- match input.chars().next() {
- Some(ch) if UnicodeXID::is_xid_continue(ch) => IResult::Error,
- Some(_) | None => IResult::Done(input, ()),
- }
-}
-
-pub fn skip_whitespace(input: &str) -> &str {
- match whitespace(input) {
- IResult::Done(rest, _) => rest,
- IResult::Error => input,
- }
-}
-
-fn is_whitespace(ch: char) -> bool {
- // Rust treats left-to-right mark and right-to-left mark as whitespace
- ch.is_whitespace() || ch == '\u{200e}' || ch == '\u{200f}'
-}
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"f3e106aaaa534eb9090f1213ff5d0c7f9861ede7f1c973d9e0e13b4a84cb7791","COPYRIGHT":"23860c2a7b5d96b21569afedf033469bab9fe14a1b24a35068b8641c578ce24d","Cargo.toml":"1be08526c07c40136071faf603a382456ad1a6bafbb45d9ace01c52b50a9a55c","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0","README.md":"67998486b32f4fe46abbbaa411b92528750e7f0e22452dc8a5b95d87d80fde75","scripts/unicode.py":"762eea92dd51238c6bf877570bde1149932ba15cf87be1618fc21cd53e941733","src/lib.rs":"4a89fadf452ae7c53536eaa4496f951a3153f8189dd1cbc532648731d30f0b11","src/tables.rs":"0643459b6ebeeed83aecd7604f0ea29c06bea7ce6c1cd9acd4988d27ace1ec53","src/tests.rs":"35a459382e190197e7b9a78832ae79f310b48a02a5b4227bf9bbc89d46c8deac"},"package":"8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/.travis.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-language: rust
-rust: 'nightly'
-sudo: false
-script:
- - cargo build --verbose --features bench
- - cargo test --verbose --features bench
- - cargo bench --verbose --features bench
- - cargo clean
- - cargo build --verbose
- - cargo test --verbose
- - rustdoc --test README.md -L target/debug -L target/debug/deps
- - cargo doc
-after_success: |
- [ $TRAVIS_BRANCH = master ] &&
- [ $TRAVIS_PULL_REQUEST = false ] &&
- echo '<meta http-equiv=refresh content=0;url=unicode_xid/index.html>' > target/doc/index.html &&
- pip install ghp-import --user $USER &&
- $HOME/.local/bin/ghp-import -n target/doc &&
- git push -qf https://${TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
-env:
- global:
- secure: gTlge+/OQlVkV0R+RThWXeN0aknmS7iUTPBMYKJyRdLz7T2vubw3w80a2CVE87JlpV87A5cVGD+LgR+AhYrhKtvqHb1brMDd99gylBBi2DfV7YapDSwSCuFgVR+FjZfJRcXBtI8po5urUZ84V0WLzRX8SyWqWgoD3oCkSL3Wp3w=
-notifications:
- email:
- on_success: never
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/COPYRIGHT
+++ /dev/null
@@ -1,7 +0,0 @@
-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. All files in the project carrying such
-notice may not be copied, modified, or distributed except
-according to those terms.
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-
-name = "unicode-xid"
-version = "0.0.4"
-authors = ["erick.tryzelaar <erick.tryzelaar@gmail.com>",
- "kwantam <kwantam@gmail.com>",
- ]
-
-homepage = "https://github.com/unicode-rs/unicode-xid"
-repository = "https://github.com/unicode-rs/unicode-xid"
-documentation = "https://unicode-rs.github.io/unicode-xid"
-license = "MIT/Apache-2.0"
-keywords = ["text", "unicode", "xid"]
-readme = "README.md"
-description = """
-Determine whether characters have the XID_Start
-or XID_Continue properties according to
-Unicode Standard Annex #31.
-"""
-
-exclude = [ "target/*", "Cargo.lock" ]
-
-[features]
-default = []
-no_std = []
-bench = []
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2015 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# unicode-xid
-
-Determine if a `char` is a valid identifier for a parser and/or lexer according to
-[Unicode Standard Annex #31](http://www.unicode.org/reports/tr31/) rules.
-
-[](https://travis-ci.org/unicode-rs/unicode-xid)
-
-[Documentation](https://unicode-rs.github.io/unicode-xid/unicode_xid/index.html)
-
-```rust
-extern crate unicode_xid;
-
-use unicode_xid::UnicodeXID;
-
-fn main() {
- let ch = 'a';
- println!("Is {} a valid start of an identifier? {}", ch, UnicodeXID::is_xid_start(ch));
-}
-```
-
-# features
-
-unicode-xid supports a `no_std` feature. This eliminates dependence
-on std, and instead uses equivalent functions from core.
-
-# crates.io
-
-You can use this package in your project by adding the following
-to your `Cargo.toml`:
-
-```toml
-[dependencies]
-unicode-xid = "0.0.4"
-```
deleted file mode 100755
--- a/third_party/rust/unicode-xid-0.0.4/scripts/unicode.py
+++ /dev/null
@@ -1,187 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2011-2015 The Rust Project Developers. See the COPYRIGHT
-# file at the top-level directory of this distribution and at
-# http://rust-lang.org/COPYRIGHT.
-#
-# 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.
-
-# This script uses the following Unicode tables:
-# - DerivedCoreProperties.txt
-# - ReadMe.txt
-#
-# Since this should not require frequent updates, we just store this
-# out-of-line and check the unicode.rs file into git.
-
-import fileinput, re, os, sys
-
-preamble = '''// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// 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.
-
-// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
-
-#![allow(missing_docs, non_upper_case_globals, non_snake_case)]
-'''
-
-def fetch(f):
- if not os.path.exists(os.path.basename(f)):
- os.system("curl -O http://www.unicode.org/Public/UNIDATA/%s"
- % f)
-
- if not os.path.exists(os.path.basename(f)):
- sys.stderr.write("cannot load %s" % f)
- exit(1)
-
-def group_cat(cat):
- cat_out = []
- letters = sorted(set(cat))
- cur_start = letters.pop(0)
- cur_end = cur_start
- for letter in letters:
- assert letter > cur_end, \
- "cur_end: %s, letter: %s" % (hex(cur_end), hex(letter))
- if letter == cur_end + 1:
- cur_end = letter
- else:
- cat_out.append((cur_start, cur_end))
- cur_start = cur_end = letter
- cat_out.append((cur_start, cur_end))
- return cat_out
-
-def ungroup_cat(cat):
- cat_out = []
- for (lo, hi) in cat:
- while lo <= hi:
- cat_out.append(lo)
- lo += 1
- return cat_out
-
-def format_table_content(f, content, indent):
- line = " "*indent
- first = True
- for chunk in content.split(","):
- if len(line) + len(chunk) < 98:
- if first:
- line += chunk
- else:
- line += ", " + chunk
- first = False
- else:
- f.write(line + ",\n")
- line = " "*indent + chunk
- f.write(line)
-
-def load_properties(f, interestingprops):
- fetch(f)
- props = {}
- re1 = re.compile("^ *([0-9A-F]+) *; *(\w+)")
- re2 = re.compile("^ *([0-9A-F]+)\.\.([0-9A-F]+) *; *(\w+)")
-
- for line in fileinput.input(os.path.basename(f)):
- prop = None
- d_lo = 0
- d_hi = 0
- m = re1.match(line)
- if m:
- d_lo = m.group(1)
- d_hi = m.group(1)
- prop = m.group(2)
- else:
- m = re2.match(line)
- if m:
- d_lo = m.group(1)
- d_hi = m.group(2)
- prop = m.group(3)
- else:
- continue
- if interestingprops and prop not in interestingprops:
- continue
- d_lo = int(d_lo, 16)
- d_hi = int(d_hi, 16)
- if prop not in props:
- props[prop] = []
- props[prop].append((d_lo, d_hi))
-
- # optimize if possible
- for prop in props:
- props[prop] = group_cat(ungroup_cat(props[prop]))
-
- return props
-
-def escape_char(c):
- return "'\\u{%x}'" % c
-
-def emit_bsearch_range_table(f):
- f.write("""
-fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
- use core::cmp::Ordering::{Equal, Less, Greater};
-
- r.binary_search_by(|&(lo,hi)| {
- if lo <= c && c <= hi { Equal }
- else if hi < c { Less }
- else { Greater }
- }).is_ok()
-}\n
-""")
-
-def emit_table(f, name, t_data, t_type = "&'static [(char, char)]", is_pub=True,
- pfun=lambda x: "(%s,%s)" % (escape_char(x[0]), escape_char(x[1])), is_const=True):
- pub_string = "const"
- if not is_const:
- pub_string = "let"
- if is_pub:
- pub_string = "pub " + pub_string
- f.write(" %s %s: %s = &[\n" % (pub_string, name, t_type))
- data = ""
- first = True
- for dat in t_data:
- if not first:
- data += ","
- first = False
- data += pfun(dat)
- format_table_content(f, data, 8)
- f.write("\n ];\n\n")
-
-def emit_property_module(f, mod, tbl, emit):
- f.write("pub mod %s {\n" % mod)
- for cat in sorted(emit):
- emit_table(f, "%s_table" % cat, tbl[cat])
- f.write(" pub fn %s(c: char) -> bool {\n" % cat)
- f.write(" super::bsearch_range_table(c, %s_table)\n" % cat)
- f.write(" }\n\n")
- f.write("}\n\n")
-
-if __name__ == "__main__":
- r = "tables.rs"
- if os.path.exists(r):
- os.remove(r)
- with open(r, "w") as rf:
- # write the file's preamble
- rf.write(preamble)
-
- # download and parse all the data
- fetch("ReadMe.txt")
- with open("ReadMe.txt") as readme:
- pattern = "for Version (\d+)\.(\d+)\.(\d+) of the Unicode"
- unicode_version = re.search(pattern, readme.read()).groups()
- rf.write("""
-/// The version of [Unicode](http://www.unicode.org/)
-/// that this version of unicode-xid is based on.
-pub const UNICODE_VERSION: (u64, u64, u64) = (%s, %s, %s);
-""" % unicode_version)
- emit_bsearch_range_table(rf)
-
- want_derived = ["XID_Start", "XID_Continue"]
- derived = load_properties("DerivedCoreProperties.txt", want_derived)
- emit_property_module(rf, "derived_property", derived, want_derived)
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/src/lib.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// 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.
-
-//! Determine if a `char` is a valid identifier for a parser and/or lexer according to
-//! [Unicode Standard Annex #31](http://www.unicode.org/reports/tr31/) rules.
-//!
-//! ```rust
-//! extern crate unicode_xid;
-//!
-//! use unicode_xid::UnicodeXID;
-//!
-//! fn main() {
-//! let ch = 'a';
-//! println!("Is {} a valid start of an identifier? {}", ch, UnicodeXID::is_xid_start(ch));
-//! }
-//! ```
-//!
-//! # features
-//!
-//! unicode-xid supports a `no_std` feature. This eliminates dependence
-//! on std, and instead uses equivalent functions from core.
-//!
-//! # crates.io
-//!
-//! You can use this package in your project by adding the following
-//! to your `Cargo.toml`:
-//!
-//! ```toml
-//! [dependencies]
-//! unicode-xid = "0.0.4"
-//! ```
-
-#![deny(missing_docs, unsafe_code)]
-#![doc(html_logo_url = "https://unicode-rs.github.io/unicode-rs_sm.png",
- html_favicon_url = "https://unicode-rs.github.io/unicode-rs_sm.png")]
-
-#![no_std]
-#![cfg_attr(feature = "bench", feature(test, unicode))]
-
-#[cfg(test)]
-#[macro_use]
-extern crate std;
-
-#[cfg(feature = "bench")]
-extern crate test;
-
-use tables::derived_property;
-pub use tables::UNICODE_VERSION;
-
-mod tables;
-
-#[cfg(test)]
-mod tests;
-
-/// Methods for determining if a character is a valid identifier character.
-pub trait UnicodeXID {
- /// Returns whether the specified character satisfies the 'XID_Start'
- /// Unicode property.
- ///
- /// 'XID_Start' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to ID_Start but modified for closure under NFKx.
- fn is_xid_start(self) -> bool;
-
- /// Returns whether the specified `char` satisfies the 'XID_Continue'
- /// Unicode property.
- ///
- /// 'XID_Continue' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
- fn is_xid_continue(self) -> bool;
-}
-
-impl UnicodeXID for char {
- #[inline]
- fn is_xid_start(self) -> bool { derived_property::XID_Start(self) }
-
- #[inline]
- fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) }
-}
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/src/tables.rs
+++ /dev/null
@@ -1,426 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// 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.
-
-// NOTE: The following code was generated by "scripts/unicode.py", do not edit directly
-
-#![allow(missing_docs, non_upper_case_globals, non_snake_case)]
-
-/// The version of [Unicode](http://www.unicode.org/)
-/// that this version of unicode-xid is based on.
-pub const UNICODE_VERSION: (u64, u64, u64) = (9, 0, 0);
-
-fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
- use core::cmp::Ordering::{Equal, Less, Greater};
-
- r.binary_search_by(|&(lo,hi)| {
- if lo <= c && c <= hi { Equal }
- else if hi < c { Less }
- else { Greater }
- }).is_ok()
-}
-
-pub mod derived_property {
- pub const XID_Continue_table: &'static [(char, char)] = &[
- ('\u{30}', '\u{39}'), ('\u{41}', '\u{5a}'), ('\u{5f}', '\u{5f}'), ('\u{61}', '\u{7a}'),
- ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'), ('\u{b7}', '\u{b7}'), ('\u{ba}', '\u{ba}'),
- ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{2c1}'), ('\u{2c6}', '\u{2d1}'),
- ('\u{2e0}', '\u{2e4}'), ('\u{2ec}', '\u{2ec}'), ('\u{2ee}', '\u{2ee}'), ('\u{300}',
- '\u{374}'), ('\u{376}', '\u{377}'), ('\u{37b}', '\u{37d}'), ('\u{37f}', '\u{37f}'),
- ('\u{386}', '\u{38a}'), ('\u{38c}', '\u{38c}'), ('\u{38e}', '\u{3a1}'), ('\u{3a3}',
- '\u{3f5}'), ('\u{3f7}', '\u{481}'), ('\u{483}', '\u{487}'), ('\u{48a}', '\u{52f}'),
- ('\u{531}', '\u{556}'), ('\u{559}', '\u{559}'), ('\u{561}', '\u{587}'), ('\u{591}',
- '\u{5bd}'), ('\u{5bf}', '\u{5bf}'), ('\u{5c1}', '\u{5c2}'), ('\u{5c4}', '\u{5c5}'),
- ('\u{5c7}', '\u{5c7}'), ('\u{5d0}', '\u{5ea}'), ('\u{5f0}', '\u{5f2}'), ('\u{610}',
- '\u{61a}'), ('\u{620}', '\u{669}'), ('\u{66e}', '\u{6d3}'), ('\u{6d5}', '\u{6dc}'),
- ('\u{6df}', '\u{6e8}'), ('\u{6ea}', '\u{6fc}'), ('\u{6ff}', '\u{6ff}'), ('\u{710}',
- '\u{74a}'), ('\u{74d}', '\u{7b1}'), ('\u{7c0}', '\u{7f5}'), ('\u{7fa}', '\u{7fa}'),
- ('\u{800}', '\u{82d}'), ('\u{840}', '\u{85b}'), ('\u{8a0}', '\u{8b4}'), ('\u{8b6}',
- '\u{8bd}'), ('\u{8d4}', '\u{8e1}'), ('\u{8e3}', '\u{963}'), ('\u{966}', '\u{96f}'),
- ('\u{971}', '\u{983}'), ('\u{985}', '\u{98c}'), ('\u{98f}', '\u{990}'), ('\u{993}',
- '\u{9a8}'), ('\u{9aa}', '\u{9b0}'), ('\u{9b2}', '\u{9b2}'), ('\u{9b6}', '\u{9b9}'),
- ('\u{9bc}', '\u{9c4}'), ('\u{9c7}', '\u{9c8}'), ('\u{9cb}', '\u{9ce}'), ('\u{9d7}',
- '\u{9d7}'), ('\u{9dc}', '\u{9dd}'), ('\u{9df}', '\u{9e3}'), ('\u{9e6}', '\u{9f1}'),
- ('\u{a01}', '\u{a03}'), ('\u{a05}', '\u{a0a}'), ('\u{a0f}', '\u{a10}'), ('\u{a13}',
- '\u{a28}'), ('\u{a2a}', '\u{a30}'), ('\u{a32}', '\u{a33}'), ('\u{a35}', '\u{a36}'),
- ('\u{a38}', '\u{a39}'), ('\u{a3c}', '\u{a3c}'), ('\u{a3e}', '\u{a42}'), ('\u{a47}',
- '\u{a48}'), ('\u{a4b}', '\u{a4d}'), ('\u{a51}', '\u{a51}'), ('\u{a59}', '\u{a5c}'),
- ('\u{a5e}', '\u{a5e}'), ('\u{a66}', '\u{a75}'), ('\u{a81}', '\u{a83}'), ('\u{a85}',
- '\u{a8d}'), ('\u{a8f}', '\u{a91}'), ('\u{a93}', '\u{aa8}'), ('\u{aaa}', '\u{ab0}'),
- ('\u{ab2}', '\u{ab3}'), ('\u{ab5}', '\u{ab9}'), ('\u{abc}', '\u{ac5}'), ('\u{ac7}',
- '\u{ac9}'), ('\u{acb}', '\u{acd}'), ('\u{ad0}', '\u{ad0}'), ('\u{ae0}', '\u{ae3}'),
- ('\u{ae6}', '\u{aef}'), ('\u{af9}', '\u{af9}'), ('\u{b01}', '\u{b03}'), ('\u{b05}',
- '\u{b0c}'), ('\u{b0f}', '\u{b10}'), ('\u{b13}', '\u{b28}'), ('\u{b2a}', '\u{b30}'),
- ('\u{b32}', '\u{b33}'), ('\u{b35}', '\u{b39}'), ('\u{b3c}', '\u{b44}'), ('\u{b47}',
- '\u{b48}'), ('\u{b4b}', '\u{b4d}'), ('\u{b56}', '\u{b57}'), ('\u{b5c}', '\u{b5d}'),
- ('\u{b5f}', '\u{b63}'), ('\u{b66}', '\u{b6f}'), ('\u{b71}', '\u{b71}'), ('\u{b82}',
- '\u{b83}'), ('\u{b85}', '\u{b8a}'), ('\u{b8e}', '\u{b90}'), ('\u{b92}', '\u{b95}'),
- ('\u{b99}', '\u{b9a}'), ('\u{b9c}', '\u{b9c}'), ('\u{b9e}', '\u{b9f}'), ('\u{ba3}',
- '\u{ba4}'), ('\u{ba8}', '\u{baa}'), ('\u{bae}', '\u{bb9}'), ('\u{bbe}', '\u{bc2}'),
- ('\u{bc6}', '\u{bc8}'), ('\u{bca}', '\u{bcd}'), ('\u{bd0}', '\u{bd0}'), ('\u{bd7}',
- '\u{bd7}'), ('\u{be6}', '\u{bef}'), ('\u{c00}', '\u{c03}'), ('\u{c05}', '\u{c0c}'),
- ('\u{c0e}', '\u{c10}'), ('\u{c12}', '\u{c28}'), ('\u{c2a}', '\u{c39}'), ('\u{c3d}',
- '\u{c44}'), ('\u{c46}', '\u{c48}'), ('\u{c4a}', '\u{c4d}'), ('\u{c55}', '\u{c56}'),
- ('\u{c58}', '\u{c5a}'), ('\u{c60}', '\u{c63}'), ('\u{c66}', '\u{c6f}'), ('\u{c80}',
- '\u{c83}'), ('\u{c85}', '\u{c8c}'), ('\u{c8e}', '\u{c90}'), ('\u{c92}', '\u{ca8}'),
- ('\u{caa}', '\u{cb3}'), ('\u{cb5}', '\u{cb9}'), ('\u{cbc}', '\u{cc4}'), ('\u{cc6}',
- '\u{cc8}'), ('\u{cca}', '\u{ccd}'), ('\u{cd5}', '\u{cd6}'), ('\u{cde}', '\u{cde}'),
- ('\u{ce0}', '\u{ce3}'), ('\u{ce6}', '\u{cef}'), ('\u{cf1}', '\u{cf2}'), ('\u{d01}',
- '\u{d03}'), ('\u{d05}', '\u{d0c}'), ('\u{d0e}', '\u{d10}'), ('\u{d12}', '\u{d3a}'),
- ('\u{d3d}', '\u{d44}'), ('\u{d46}', '\u{d48}'), ('\u{d4a}', '\u{d4e}'), ('\u{d54}',
- '\u{d57}'), ('\u{d5f}', '\u{d63}'), ('\u{d66}', '\u{d6f}'), ('\u{d7a}', '\u{d7f}'),
- ('\u{d82}', '\u{d83}'), ('\u{d85}', '\u{d96}'), ('\u{d9a}', '\u{db1}'), ('\u{db3}',
- '\u{dbb}'), ('\u{dbd}', '\u{dbd}'), ('\u{dc0}', '\u{dc6}'), ('\u{dca}', '\u{dca}'),
- ('\u{dcf}', '\u{dd4}'), ('\u{dd6}', '\u{dd6}'), ('\u{dd8}', '\u{ddf}'), ('\u{de6}',
- '\u{def}'), ('\u{df2}', '\u{df3}'), ('\u{e01}', '\u{e3a}'), ('\u{e40}', '\u{e4e}'),
- ('\u{e50}', '\u{e59}'), ('\u{e81}', '\u{e82}'), ('\u{e84}', '\u{e84}'), ('\u{e87}',
- '\u{e88}'), ('\u{e8a}', '\u{e8a}'), ('\u{e8d}', '\u{e8d}'), ('\u{e94}', '\u{e97}'),
- ('\u{e99}', '\u{e9f}'), ('\u{ea1}', '\u{ea3}'), ('\u{ea5}', '\u{ea5}'), ('\u{ea7}',
- '\u{ea7}'), ('\u{eaa}', '\u{eab}'), ('\u{ead}', '\u{eb9}'), ('\u{ebb}', '\u{ebd}'),
- ('\u{ec0}', '\u{ec4}'), ('\u{ec6}', '\u{ec6}'), ('\u{ec8}', '\u{ecd}'), ('\u{ed0}',
- '\u{ed9}'), ('\u{edc}', '\u{edf}'), ('\u{f00}', '\u{f00}'), ('\u{f18}', '\u{f19}'),
- ('\u{f20}', '\u{f29}'), ('\u{f35}', '\u{f35}'), ('\u{f37}', '\u{f37}'), ('\u{f39}',
- '\u{f39}'), ('\u{f3e}', '\u{f47}'), ('\u{f49}', '\u{f6c}'), ('\u{f71}', '\u{f84}'),
- ('\u{f86}', '\u{f97}'), ('\u{f99}', '\u{fbc}'), ('\u{fc6}', '\u{fc6}'), ('\u{1000}',
- '\u{1049}'), ('\u{1050}', '\u{109d}'), ('\u{10a0}', '\u{10c5}'), ('\u{10c7}', '\u{10c7}'),
- ('\u{10cd}', '\u{10cd}'), ('\u{10d0}', '\u{10fa}'), ('\u{10fc}', '\u{1248}'), ('\u{124a}',
- '\u{124d}'), ('\u{1250}', '\u{1256}'), ('\u{1258}', '\u{1258}'), ('\u{125a}', '\u{125d}'),
- ('\u{1260}', '\u{1288}'), ('\u{128a}', '\u{128d}'), ('\u{1290}', '\u{12b0}'), ('\u{12b2}',
- '\u{12b5}'), ('\u{12b8}', '\u{12be}'), ('\u{12c0}', '\u{12c0}'), ('\u{12c2}', '\u{12c5}'),
- ('\u{12c8}', '\u{12d6}'), ('\u{12d8}', '\u{1310}'), ('\u{1312}', '\u{1315}'), ('\u{1318}',
- '\u{135a}'), ('\u{135d}', '\u{135f}'), ('\u{1369}', '\u{1371}'), ('\u{1380}', '\u{138f}'),
- ('\u{13a0}', '\u{13f5}'), ('\u{13f8}', '\u{13fd}'), ('\u{1401}', '\u{166c}'), ('\u{166f}',
- '\u{167f}'), ('\u{1681}', '\u{169a}'), ('\u{16a0}', '\u{16ea}'), ('\u{16ee}', '\u{16f8}'),
- ('\u{1700}', '\u{170c}'), ('\u{170e}', '\u{1714}'), ('\u{1720}', '\u{1734}'), ('\u{1740}',
- '\u{1753}'), ('\u{1760}', '\u{176c}'), ('\u{176e}', '\u{1770}'), ('\u{1772}', '\u{1773}'),
- ('\u{1780}', '\u{17d3}'), ('\u{17d7}', '\u{17d7}'), ('\u{17dc}', '\u{17dd}'), ('\u{17e0}',
- '\u{17e9}'), ('\u{180b}', '\u{180d}'), ('\u{1810}', '\u{1819}'), ('\u{1820}', '\u{1877}'),
- ('\u{1880}', '\u{18aa}'), ('\u{18b0}', '\u{18f5}'), ('\u{1900}', '\u{191e}'), ('\u{1920}',
- '\u{192b}'), ('\u{1930}', '\u{193b}'), ('\u{1946}', '\u{196d}'), ('\u{1970}', '\u{1974}'),
- ('\u{1980}', '\u{19ab}'), ('\u{19b0}', '\u{19c9}'), ('\u{19d0}', '\u{19da}'), ('\u{1a00}',
- '\u{1a1b}'), ('\u{1a20}', '\u{1a5e}'), ('\u{1a60}', '\u{1a7c}'), ('\u{1a7f}', '\u{1a89}'),
- ('\u{1a90}', '\u{1a99}'), ('\u{1aa7}', '\u{1aa7}'), ('\u{1ab0}', '\u{1abd}'), ('\u{1b00}',
- '\u{1b4b}'), ('\u{1b50}', '\u{1b59}'), ('\u{1b6b}', '\u{1b73}'), ('\u{1b80}', '\u{1bf3}'),
- ('\u{1c00}', '\u{1c37}'), ('\u{1c40}', '\u{1c49}'), ('\u{1c4d}', '\u{1c7d}'), ('\u{1c80}',
- '\u{1c88}'), ('\u{1cd0}', '\u{1cd2}'), ('\u{1cd4}', '\u{1cf6}'), ('\u{1cf8}', '\u{1cf9}'),
- ('\u{1d00}', '\u{1df5}'), ('\u{1dfb}', '\u{1f15}'), ('\u{1f18}', '\u{1f1d}'), ('\u{1f20}',
- '\u{1f45}'), ('\u{1f48}', '\u{1f4d}'), ('\u{1f50}', '\u{1f57}'), ('\u{1f59}', '\u{1f59}'),
- ('\u{1f5b}', '\u{1f5b}'), ('\u{1f5d}', '\u{1f5d}'), ('\u{1f5f}', '\u{1f7d}'), ('\u{1f80}',
- '\u{1fb4}'), ('\u{1fb6}', '\u{1fbc}'), ('\u{1fbe}', '\u{1fbe}'), ('\u{1fc2}', '\u{1fc4}'),
- ('\u{1fc6}', '\u{1fcc}'), ('\u{1fd0}', '\u{1fd3}'), ('\u{1fd6}', '\u{1fdb}'), ('\u{1fe0}',
- '\u{1fec}'), ('\u{1ff2}', '\u{1ff4}'), ('\u{1ff6}', '\u{1ffc}'), ('\u{203f}', '\u{2040}'),
- ('\u{2054}', '\u{2054}'), ('\u{2071}', '\u{2071}'), ('\u{207f}', '\u{207f}'), ('\u{2090}',
- '\u{209c}'), ('\u{20d0}', '\u{20dc}'), ('\u{20e1}', '\u{20e1}'), ('\u{20e5}', '\u{20f0}'),
- ('\u{2102}', '\u{2102}'), ('\u{2107}', '\u{2107}'), ('\u{210a}', '\u{2113}'), ('\u{2115}',
- '\u{2115}'), ('\u{2118}', '\u{211d}'), ('\u{2124}', '\u{2124}'), ('\u{2126}', '\u{2126}'),
- ('\u{2128}', '\u{2128}'), ('\u{212a}', '\u{2139}'), ('\u{213c}', '\u{213f}'), ('\u{2145}',
- '\u{2149}'), ('\u{214e}', '\u{214e}'), ('\u{2160}', '\u{2188}'), ('\u{2c00}', '\u{2c2e}'),
- ('\u{2c30}', '\u{2c5e}'), ('\u{2c60}', '\u{2ce4}'), ('\u{2ceb}', '\u{2cf3}'), ('\u{2d00}',
- '\u{2d25}'), ('\u{2d27}', '\u{2d27}'), ('\u{2d2d}', '\u{2d2d}'), ('\u{2d30}', '\u{2d67}'),
- ('\u{2d6f}', '\u{2d6f}'), ('\u{2d7f}', '\u{2d96}'), ('\u{2da0}', '\u{2da6}'), ('\u{2da8}',
- '\u{2dae}'), ('\u{2db0}', '\u{2db6}'), ('\u{2db8}', '\u{2dbe}'), ('\u{2dc0}', '\u{2dc6}'),
- ('\u{2dc8}', '\u{2dce}'), ('\u{2dd0}', '\u{2dd6}'), ('\u{2dd8}', '\u{2dde}'), ('\u{2de0}',
- '\u{2dff}'), ('\u{3005}', '\u{3007}'), ('\u{3021}', '\u{302f}'), ('\u{3031}', '\u{3035}'),
- ('\u{3038}', '\u{303c}'), ('\u{3041}', '\u{3096}'), ('\u{3099}', '\u{309a}'), ('\u{309d}',
- '\u{309f}'), ('\u{30a1}', '\u{30fa}'), ('\u{30fc}', '\u{30ff}'), ('\u{3105}', '\u{312d}'),
- ('\u{3131}', '\u{318e}'), ('\u{31a0}', '\u{31ba}'), ('\u{31f0}', '\u{31ff}'), ('\u{3400}',
- '\u{4db5}'), ('\u{4e00}', '\u{9fd5}'), ('\u{a000}', '\u{a48c}'), ('\u{a4d0}', '\u{a4fd}'),
- ('\u{a500}', '\u{a60c}'), ('\u{a610}', '\u{a62b}'), ('\u{a640}', '\u{a66f}'), ('\u{a674}',
- '\u{a67d}'), ('\u{a67f}', '\u{a6f1}'), ('\u{a717}', '\u{a71f}'), ('\u{a722}', '\u{a788}'),
- ('\u{a78b}', '\u{a7ae}'), ('\u{a7b0}', '\u{a7b7}'), ('\u{a7f7}', '\u{a827}'), ('\u{a840}',
- '\u{a873}'), ('\u{a880}', '\u{a8c5}'), ('\u{a8d0}', '\u{a8d9}'), ('\u{a8e0}', '\u{a8f7}'),
- ('\u{a8fb}', '\u{a8fb}'), ('\u{a8fd}', '\u{a8fd}'), ('\u{a900}', '\u{a92d}'), ('\u{a930}',
- '\u{a953}'), ('\u{a960}', '\u{a97c}'), ('\u{a980}', '\u{a9c0}'), ('\u{a9cf}', '\u{a9d9}'),
- ('\u{a9e0}', '\u{a9fe}'), ('\u{aa00}', '\u{aa36}'), ('\u{aa40}', '\u{aa4d}'), ('\u{aa50}',
- '\u{aa59}'), ('\u{aa60}', '\u{aa76}'), ('\u{aa7a}', '\u{aac2}'), ('\u{aadb}', '\u{aadd}'),
- ('\u{aae0}', '\u{aaef}'), ('\u{aaf2}', '\u{aaf6}'), ('\u{ab01}', '\u{ab06}'), ('\u{ab09}',
- '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}', '\u{ab26}'), ('\u{ab28}', '\u{ab2e}'),
- ('\u{ab30}', '\u{ab5a}'), ('\u{ab5c}', '\u{ab65}'), ('\u{ab70}', '\u{abea}'), ('\u{abec}',
- '\u{abed}'), ('\u{abf0}', '\u{abf9}'), ('\u{ac00}', '\u{d7a3}'), ('\u{d7b0}', '\u{d7c6}'),
- ('\u{d7cb}', '\u{d7fb}'), ('\u{f900}', '\u{fa6d}'), ('\u{fa70}', '\u{fad9}'), ('\u{fb00}',
- '\u{fb06}'), ('\u{fb13}', '\u{fb17}'), ('\u{fb1d}', '\u{fb28}'), ('\u{fb2a}', '\u{fb36}'),
- ('\u{fb38}', '\u{fb3c}'), ('\u{fb3e}', '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}',
- '\u{fb44}'), ('\u{fb46}', '\u{fbb1}'), ('\u{fbd3}', '\u{fc5d}'), ('\u{fc64}', '\u{fd3d}'),
- ('\u{fd50}', '\u{fd8f}'), ('\u{fd92}', '\u{fdc7}'), ('\u{fdf0}', '\u{fdf9}'), ('\u{fe00}',
- '\u{fe0f}'), ('\u{fe20}', '\u{fe2f}'), ('\u{fe33}', '\u{fe34}'), ('\u{fe4d}', '\u{fe4f}'),
- ('\u{fe71}', '\u{fe71}'), ('\u{fe73}', '\u{fe73}'), ('\u{fe77}', '\u{fe77}'), ('\u{fe79}',
- '\u{fe79}'), ('\u{fe7b}', '\u{fe7b}'), ('\u{fe7d}', '\u{fe7d}'), ('\u{fe7f}', '\u{fefc}'),
- ('\u{ff10}', '\u{ff19}'), ('\u{ff21}', '\u{ff3a}'), ('\u{ff3f}', '\u{ff3f}'), ('\u{ff41}',
- '\u{ff5a}'), ('\u{ff66}', '\u{ffbe}'), ('\u{ffc2}', '\u{ffc7}'), ('\u{ffca}', '\u{ffcf}'),
- ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}'), ('\u{10000}', '\u{1000b}'),
- ('\u{1000d}', '\u{10026}'), ('\u{10028}', '\u{1003a}'), ('\u{1003c}', '\u{1003d}'),
- ('\u{1003f}', '\u{1004d}'), ('\u{10050}', '\u{1005d}'), ('\u{10080}', '\u{100fa}'),
- ('\u{10140}', '\u{10174}'), ('\u{101fd}', '\u{101fd}'), ('\u{10280}', '\u{1029c}'),
- ('\u{102a0}', '\u{102d0}'), ('\u{102e0}', '\u{102e0}'), ('\u{10300}', '\u{1031f}'),
- ('\u{10330}', '\u{1034a}'), ('\u{10350}', '\u{1037a}'), ('\u{10380}', '\u{1039d}'),
- ('\u{103a0}', '\u{103c3}'), ('\u{103c8}', '\u{103cf}'), ('\u{103d1}', '\u{103d5}'),
- ('\u{10400}', '\u{1049d}'), ('\u{104a0}', '\u{104a9}'), ('\u{104b0}', '\u{104d3}'),
- ('\u{104d8}', '\u{104fb}'), ('\u{10500}', '\u{10527}'), ('\u{10530}', '\u{10563}'),
- ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'), ('\u{10760}', '\u{10767}'),
- ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'), ('\u{1080a}', '\u{10835}'),
- ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'), ('\u{1083f}', '\u{10855}'),
- ('\u{10860}', '\u{10876}'), ('\u{10880}', '\u{1089e}'), ('\u{108e0}', '\u{108f2}'),
- ('\u{108f4}', '\u{108f5}'), ('\u{10900}', '\u{10915}'), ('\u{10920}', '\u{10939}'),
- ('\u{10980}', '\u{109b7}'), ('\u{109be}', '\u{109bf}'), ('\u{10a00}', '\u{10a03}'),
- ('\u{10a05}', '\u{10a06}'), ('\u{10a0c}', '\u{10a13}'), ('\u{10a15}', '\u{10a17}'),
- ('\u{10a19}', '\u{10a33}'), ('\u{10a38}', '\u{10a3a}'), ('\u{10a3f}', '\u{10a3f}'),
- ('\u{10a60}', '\u{10a7c}'), ('\u{10a80}', '\u{10a9c}'), ('\u{10ac0}', '\u{10ac7}'),
- ('\u{10ac9}', '\u{10ae6}'), ('\u{10b00}', '\u{10b35}'), ('\u{10b40}', '\u{10b55}'),
- ('\u{10b60}', '\u{10b72}'), ('\u{10b80}', '\u{10b91}'), ('\u{10c00}', '\u{10c48}'),
- ('\u{10c80}', '\u{10cb2}'), ('\u{10cc0}', '\u{10cf2}'), ('\u{11000}', '\u{11046}'),
- ('\u{11066}', '\u{1106f}'), ('\u{1107f}', '\u{110ba}'), ('\u{110d0}', '\u{110e8}'),
- ('\u{110f0}', '\u{110f9}'), ('\u{11100}', '\u{11134}'), ('\u{11136}', '\u{1113f}'),
- ('\u{11150}', '\u{11173}'), ('\u{11176}', '\u{11176}'), ('\u{11180}', '\u{111c4}'),
- ('\u{111ca}', '\u{111cc}'), ('\u{111d0}', '\u{111da}'), ('\u{111dc}', '\u{111dc}'),
- ('\u{11200}', '\u{11211}'), ('\u{11213}', '\u{11237}'), ('\u{1123e}', '\u{1123e}'),
- ('\u{11280}', '\u{11286}'), ('\u{11288}', '\u{11288}'), ('\u{1128a}', '\u{1128d}'),
- ('\u{1128f}', '\u{1129d}'), ('\u{1129f}', '\u{112a8}'), ('\u{112b0}', '\u{112ea}'),
- ('\u{112f0}', '\u{112f9}'), ('\u{11300}', '\u{11303}'), ('\u{11305}', '\u{1130c}'),
- ('\u{1130f}', '\u{11310}'), ('\u{11313}', '\u{11328}'), ('\u{1132a}', '\u{11330}'),
- ('\u{11332}', '\u{11333}'), ('\u{11335}', '\u{11339}'), ('\u{1133c}', '\u{11344}'),
- ('\u{11347}', '\u{11348}'), ('\u{1134b}', '\u{1134d}'), ('\u{11350}', '\u{11350}'),
- ('\u{11357}', '\u{11357}'), ('\u{1135d}', '\u{11363}'), ('\u{11366}', '\u{1136c}'),
- ('\u{11370}', '\u{11374}'), ('\u{11400}', '\u{1144a}'), ('\u{11450}', '\u{11459}'),
- ('\u{11480}', '\u{114c5}'), ('\u{114c7}', '\u{114c7}'), ('\u{114d0}', '\u{114d9}'),
- ('\u{11580}', '\u{115b5}'), ('\u{115b8}', '\u{115c0}'), ('\u{115d8}', '\u{115dd}'),
- ('\u{11600}', '\u{11640}'), ('\u{11644}', '\u{11644}'), ('\u{11650}', '\u{11659}'),
- ('\u{11680}', '\u{116b7}'), ('\u{116c0}', '\u{116c9}'), ('\u{11700}', '\u{11719}'),
- ('\u{1171d}', '\u{1172b}'), ('\u{11730}', '\u{11739}'), ('\u{118a0}', '\u{118e9}'),
- ('\u{118ff}', '\u{118ff}'), ('\u{11ac0}', '\u{11af8}'), ('\u{11c00}', '\u{11c08}'),
- ('\u{11c0a}', '\u{11c36}'), ('\u{11c38}', '\u{11c40}'), ('\u{11c50}', '\u{11c59}'),
- ('\u{11c72}', '\u{11c8f}'), ('\u{11c92}', '\u{11ca7}'), ('\u{11ca9}', '\u{11cb6}'),
- ('\u{12000}', '\u{12399}'), ('\u{12400}', '\u{1246e}'), ('\u{12480}', '\u{12543}'),
- ('\u{13000}', '\u{1342e}'), ('\u{14400}', '\u{14646}'), ('\u{16800}', '\u{16a38}'),
- ('\u{16a40}', '\u{16a5e}'), ('\u{16a60}', '\u{16a69}'), ('\u{16ad0}', '\u{16aed}'),
- ('\u{16af0}', '\u{16af4}'), ('\u{16b00}', '\u{16b36}'), ('\u{16b40}', '\u{16b43}'),
- ('\u{16b50}', '\u{16b59}'), ('\u{16b63}', '\u{16b77}'), ('\u{16b7d}', '\u{16b8f}'),
- ('\u{16f00}', '\u{16f44}'), ('\u{16f50}', '\u{16f7e}'), ('\u{16f8f}', '\u{16f9f}'),
- ('\u{16fe0}', '\u{16fe0}'), ('\u{17000}', '\u{187ec}'), ('\u{18800}', '\u{18af2}'),
- ('\u{1b000}', '\u{1b001}'), ('\u{1bc00}', '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'),
- ('\u{1bc80}', '\u{1bc88}'), ('\u{1bc90}', '\u{1bc99}'), ('\u{1bc9d}', '\u{1bc9e}'),
- ('\u{1d165}', '\u{1d169}'), ('\u{1d16d}', '\u{1d172}'), ('\u{1d17b}', '\u{1d182}'),
- ('\u{1d185}', '\u{1d18b}'), ('\u{1d1aa}', '\u{1d1ad}'), ('\u{1d242}', '\u{1d244}'),
- ('\u{1d400}', '\u{1d454}'), ('\u{1d456}', '\u{1d49c}'), ('\u{1d49e}', '\u{1d49f}'),
- ('\u{1d4a2}', '\u{1d4a2}'), ('\u{1d4a5}', '\u{1d4a6}'), ('\u{1d4a9}', '\u{1d4ac}'),
- ('\u{1d4ae}', '\u{1d4b9}'), ('\u{1d4bb}', '\u{1d4bb}'), ('\u{1d4bd}', '\u{1d4c3}'),
- ('\u{1d4c5}', '\u{1d505}'), ('\u{1d507}', '\u{1d50a}'), ('\u{1d50d}', '\u{1d514}'),
- ('\u{1d516}', '\u{1d51c}'), ('\u{1d51e}', '\u{1d539}'), ('\u{1d53b}', '\u{1d53e}'),
- ('\u{1d540}', '\u{1d544}'), ('\u{1d546}', '\u{1d546}'), ('\u{1d54a}', '\u{1d550}'),
- ('\u{1d552}', '\u{1d6a5}'), ('\u{1d6a8}', '\u{1d6c0}'), ('\u{1d6c2}', '\u{1d6da}'),
- ('\u{1d6dc}', '\u{1d6fa}'), ('\u{1d6fc}', '\u{1d714}'), ('\u{1d716}', '\u{1d734}'),
- ('\u{1d736}', '\u{1d74e}'), ('\u{1d750}', '\u{1d76e}'), ('\u{1d770}', '\u{1d788}'),
- ('\u{1d78a}', '\u{1d7a8}'), ('\u{1d7aa}', '\u{1d7c2}'), ('\u{1d7c4}', '\u{1d7cb}'),
- ('\u{1d7ce}', '\u{1d7ff}'), ('\u{1da00}', '\u{1da36}'), ('\u{1da3b}', '\u{1da6c}'),
- ('\u{1da75}', '\u{1da75}'), ('\u{1da84}', '\u{1da84}'), ('\u{1da9b}', '\u{1da9f}'),
- ('\u{1daa1}', '\u{1daaf}'), ('\u{1e000}', '\u{1e006}'), ('\u{1e008}', '\u{1e018}'),
- ('\u{1e01b}', '\u{1e021}'), ('\u{1e023}', '\u{1e024}'), ('\u{1e026}', '\u{1e02a}'),
- ('\u{1e800}', '\u{1e8c4}'), ('\u{1e8d0}', '\u{1e8d6}'), ('\u{1e900}', '\u{1e94a}'),
- ('\u{1e950}', '\u{1e959}'), ('\u{1ee00}', '\u{1ee03}'), ('\u{1ee05}', '\u{1ee1f}'),
- ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}', '\u{1ee24}'), ('\u{1ee27}', '\u{1ee27}'),
- ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}', '\u{1ee37}'), ('\u{1ee39}', '\u{1ee39}'),
- ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}', '\u{1ee42}'), ('\u{1ee47}', '\u{1ee47}'),
- ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}', '\u{1ee4b}'), ('\u{1ee4d}', '\u{1ee4f}'),
- ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}', '\u{1ee54}'), ('\u{1ee57}', '\u{1ee57}'),
- ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}', '\u{1ee5b}'), ('\u{1ee5d}', '\u{1ee5d}'),
- ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}', '\u{1ee62}'), ('\u{1ee64}', '\u{1ee64}'),
- ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}', '\u{1ee72}'), ('\u{1ee74}', '\u{1ee77}'),
- ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}', '\u{1ee7e}'), ('\u{1ee80}', '\u{1ee89}'),
- ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}', '\u{1eea3}'), ('\u{1eea5}', '\u{1eea9}'),
- ('\u{1eeab}', '\u{1eebb}'), ('\u{20000}', '\u{2a6d6}'), ('\u{2a700}', '\u{2b734}'),
- ('\u{2b740}', '\u{2b81d}'), ('\u{2b820}', '\u{2cea1}'), ('\u{2f800}', '\u{2fa1d}'),
- ('\u{e0100}', '\u{e01ef}')
- ];
-
- pub fn XID_Continue(c: char) -> bool {
- super::bsearch_range_table(c, XID_Continue_table)
- }
-
- pub const XID_Start_table: &'static [(char, char)] = &[
- ('\u{41}', '\u{5a}'), ('\u{61}', '\u{7a}'), ('\u{aa}', '\u{aa}'), ('\u{b5}', '\u{b5}'),
- ('\u{ba}', '\u{ba}'), ('\u{c0}', '\u{d6}'), ('\u{d8}', '\u{f6}'), ('\u{f8}', '\u{2c1}'),
- ('\u{2c6}', '\u{2d1}'), ('\u{2e0}', '\u{2e4}'), ('\u{2ec}', '\u{2ec}'), ('\u{2ee}',
- '\u{2ee}'), ('\u{370}', '\u{374}'), ('\u{376}', '\u{377}'), ('\u{37b}', '\u{37d}'),
- ('\u{37f}', '\u{37f}'), ('\u{386}', '\u{386}'), ('\u{388}', '\u{38a}'), ('\u{38c}',
- '\u{38c}'), ('\u{38e}', '\u{3a1}'), ('\u{3a3}', '\u{3f5}'), ('\u{3f7}', '\u{481}'),
- ('\u{48a}', '\u{52f}'), ('\u{531}', '\u{556}'), ('\u{559}', '\u{559}'), ('\u{561}',
- '\u{587}'), ('\u{5d0}', '\u{5ea}'), ('\u{5f0}', '\u{5f2}'), ('\u{620}', '\u{64a}'),
- ('\u{66e}', '\u{66f}'), ('\u{671}', '\u{6d3}'), ('\u{6d5}', '\u{6d5}'), ('\u{6e5}',
- '\u{6e6}'), ('\u{6ee}', '\u{6ef}'), ('\u{6fa}', '\u{6fc}'), ('\u{6ff}', '\u{6ff}'),
- ('\u{710}', '\u{710}'), ('\u{712}', '\u{72f}'), ('\u{74d}', '\u{7a5}'), ('\u{7b1}',
- '\u{7b1}'), ('\u{7ca}', '\u{7ea}'), ('\u{7f4}', '\u{7f5}'), ('\u{7fa}', '\u{7fa}'),
- ('\u{800}', '\u{815}'), ('\u{81a}', '\u{81a}'), ('\u{824}', '\u{824}'), ('\u{828}',
- '\u{828}'), ('\u{840}', '\u{858}'), ('\u{8a0}', '\u{8b4}'), ('\u{8b6}', '\u{8bd}'),
- ('\u{904}', '\u{939}'), ('\u{93d}', '\u{93d}'), ('\u{950}', '\u{950}'), ('\u{958}',
- '\u{961}'), ('\u{971}', '\u{980}'), ('\u{985}', '\u{98c}'), ('\u{98f}', '\u{990}'),
- ('\u{993}', '\u{9a8}'), ('\u{9aa}', '\u{9b0}'), ('\u{9b2}', '\u{9b2}'), ('\u{9b6}',
- '\u{9b9}'), ('\u{9bd}', '\u{9bd}'), ('\u{9ce}', '\u{9ce}'), ('\u{9dc}', '\u{9dd}'),
- ('\u{9df}', '\u{9e1}'), ('\u{9f0}', '\u{9f1}'), ('\u{a05}', '\u{a0a}'), ('\u{a0f}',
- '\u{a10}'), ('\u{a13}', '\u{a28}'), ('\u{a2a}', '\u{a30}'), ('\u{a32}', '\u{a33}'),
- ('\u{a35}', '\u{a36}'), ('\u{a38}', '\u{a39}'), ('\u{a59}', '\u{a5c}'), ('\u{a5e}',
- '\u{a5e}'), ('\u{a72}', '\u{a74}'), ('\u{a85}', '\u{a8d}'), ('\u{a8f}', '\u{a91}'),
- ('\u{a93}', '\u{aa8}'), ('\u{aaa}', '\u{ab0}'), ('\u{ab2}', '\u{ab3}'), ('\u{ab5}',
- '\u{ab9}'), ('\u{abd}', '\u{abd}'), ('\u{ad0}', '\u{ad0}'), ('\u{ae0}', '\u{ae1}'),
- ('\u{af9}', '\u{af9}'), ('\u{b05}', '\u{b0c}'), ('\u{b0f}', '\u{b10}'), ('\u{b13}',
- '\u{b28}'), ('\u{b2a}', '\u{b30}'), ('\u{b32}', '\u{b33}'), ('\u{b35}', '\u{b39}'),
- ('\u{b3d}', '\u{b3d}'), ('\u{b5c}', '\u{b5d}'), ('\u{b5f}', '\u{b61}'), ('\u{b71}',
- '\u{b71}'), ('\u{b83}', '\u{b83}'), ('\u{b85}', '\u{b8a}'), ('\u{b8e}', '\u{b90}'),
- ('\u{b92}', '\u{b95}'), ('\u{b99}', '\u{b9a}'), ('\u{b9c}', '\u{b9c}'), ('\u{b9e}',
- '\u{b9f}'), ('\u{ba3}', '\u{ba4}'), ('\u{ba8}', '\u{baa}'), ('\u{bae}', '\u{bb9}'),
- ('\u{bd0}', '\u{bd0}'), ('\u{c05}', '\u{c0c}'), ('\u{c0e}', '\u{c10}'), ('\u{c12}',
- '\u{c28}'), ('\u{c2a}', '\u{c39}'), ('\u{c3d}', '\u{c3d}'), ('\u{c58}', '\u{c5a}'),
- ('\u{c60}', '\u{c61}'), ('\u{c80}', '\u{c80}'), ('\u{c85}', '\u{c8c}'), ('\u{c8e}',
- '\u{c90}'), ('\u{c92}', '\u{ca8}'), ('\u{caa}', '\u{cb3}'), ('\u{cb5}', '\u{cb9}'),
- ('\u{cbd}', '\u{cbd}'), ('\u{cde}', '\u{cde}'), ('\u{ce0}', '\u{ce1}'), ('\u{cf1}',
- '\u{cf2}'), ('\u{d05}', '\u{d0c}'), ('\u{d0e}', '\u{d10}'), ('\u{d12}', '\u{d3a}'),
- ('\u{d3d}', '\u{d3d}'), ('\u{d4e}', '\u{d4e}'), ('\u{d54}', '\u{d56}'), ('\u{d5f}',
- '\u{d61}'), ('\u{d7a}', '\u{d7f}'), ('\u{d85}', '\u{d96}'), ('\u{d9a}', '\u{db1}'),
- ('\u{db3}', '\u{dbb}'), ('\u{dbd}', '\u{dbd}'), ('\u{dc0}', '\u{dc6}'), ('\u{e01}',
- '\u{e30}'), ('\u{e32}', '\u{e32}'), ('\u{e40}', '\u{e46}'), ('\u{e81}', '\u{e82}'),
- ('\u{e84}', '\u{e84}'), ('\u{e87}', '\u{e88}'), ('\u{e8a}', '\u{e8a}'), ('\u{e8d}',
- '\u{e8d}'), ('\u{e94}', '\u{e97}'), ('\u{e99}', '\u{e9f}'), ('\u{ea1}', '\u{ea3}'),
- ('\u{ea5}', '\u{ea5}'), ('\u{ea7}', '\u{ea7}'), ('\u{eaa}', '\u{eab}'), ('\u{ead}',
- '\u{eb0}'), ('\u{eb2}', '\u{eb2}'), ('\u{ebd}', '\u{ebd}'), ('\u{ec0}', '\u{ec4}'),
- ('\u{ec6}', '\u{ec6}'), ('\u{edc}', '\u{edf}'), ('\u{f00}', '\u{f00}'), ('\u{f40}',
- '\u{f47}'), ('\u{f49}', '\u{f6c}'), ('\u{f88}', '\u{f8c}'), ('\u{1000}', '\u{102a}'),
- ('\u{103f}', '\u{103f}'), ('\u{1050}', '\u{1055}'), ('\u{105a}', '\u{105d}'), ('\u{1061}',
- '\u{1061}'), ('\u{1065}', '\u{1066}'), ('\u{106e}', '\u{1070}'), ('\u{1075}', '\u{1081}'),
- ('\u{108e}', '\u{108e}'), ('\u{10a0}', '\u{10c5}'), ('\u{10c7}', '\u{10c7}'), ('\u{10cd}',
- '\u{10cd}'), ('\u{10d0}', '\u{10fa}'), ('\u{10fc}', '\u{1248}'), ('\u{124a}', '\u{124d}'),
- ('\u{1250}', '\u{1256}'), ('\u{1258}', '\u{1258}'), ('\u{125a}', '\u{125d}'), ('\u{1260}',
- '\u{1288}'), ('\u{128a}', '\u{128d}'), ('\u{1290}', '\u{12b0}'), ('\u{12b2}', '\u{12b5}'),
- ('\u{12b8}', '\u{12be}'), ('\u{12c0}', '\u{12c0}'), ('\u{12c2}', '\u{12c5}'), ('\u{12c8}',
- '\u{12d6}'), ('\u{12d8}', '\u{1310}'), ('\u{1312}', '\u{1315}'), ('\u{1318}', '\u{135a}'),
- ('\u{1380}', '\u{138f}'), ('\u{13a0}', '\u{13f5}'), ('\u{13f8}', '\u{13fd}'), ('\u{1401}',
- '\u{166c}'), ('\u{166f}', '\u{167f}'), ('\u{1681}', '\u{169a}'), ('\u{16a0}', '\u{16ea}'),
- ('\u{16ee}', '\u{16f8}'), ('\u{1700}', '\u{170c}'), ('\u{170e}', '\u{1711}'), ('\u{1720}',
- '\u{1731}'), ('\u{1740}', '\u{1751}'), ('\u{1760}', '\u{176c}'), ('\u{176e}', '\u{1770}'),
- ('\u{1780}', '\u{17b3}'), ('\u{17d7}', '\u{17d7}'), ('\u{17dc}', '\u{17dc}'), ('\u{1820}',
- '\u{1877}'), ('\u{1880}', '\u{18a8}'), ('\u{18aa}', '\u{18aa}'), ('\u{18b0}', '\u{18f5}'),
- ('\u{1900}', '\u{191e}'), ('\u{1950}', '\u{196d}'), ('\u{1970}', '\u{1974}'), ('\u{1980}',
- '\u{19ab}'), ('\u{19b0}', '\u{19c9}'), ('\u{1a00}', '\u{1a16}'), ('\u{1a20}', '\u{1a54}'),
- ('\u{1aa7}', '\u{1aa7}'), ('\u{1b05}', '\u{1b33}'), ('\u{1b45}', '\u{1b4b}'), ('\u{1b83}',
- '\u{1ba0}'), ('\u{1bae}', '\u{1baf}'), ('\u{1bba}', '\u{1be5}'), ('\u{1c00}', '\u{1c23}'),
- ('\u{1c4d}', '\u{1c4f}'), ('\u{1c5a}', '\u{1c7d}'), ('\u{1c80}', '\u{1c88}'), ('\u{1ce9}',
- '\u{1cec}'), ('\u{1cee}', '\u{1cf1}'), ('\u{1cf5}', '\u{1cf6}'), ('\u{1d00}', '\u{1dbf}'),
- ('\u{1e00}', '\u{1f15}'), ('\u{1f18}', '\u{1f1d}'), ('\u{1f20}', '\u{1f45}'), ('\u{1f48}',
- '\u{1f4d}'), ('\u{1f50}', '\u{1f57}'), ('\u{1f59}', '\u{1f59}'), ('\u{1f5b}', '\u{1f5b}'),
- ('\u{1f5d}', '\u{1f5d}'), ('\u{1f5f}', '\u{1f7d}'), ('\u{1f80}', '\u{1fb4}'), ('\u{1fb6}',
- '\u{1fbc}'), ('\u{1fbe}', '\u{1fbe}'), ('\u{1fc2}', '\u{1fc4}'), ('\u{1fc6}', '\u{1fcc}'),
- ('\u{1fd0}', '\u{1fd3}'), ('\u{1fd6}', '\u{1fdb}'), ('\u{1fe0}', '\u{1fec}'), ('\u{1ff2}',
- '\u{1ff4}'), ('\u{1ff6}', '\u{1ffc}'), ('\u{2071}', '\u{2071}'), ('\u{207f}', '\u{207f}'),
- ('\u{2090}', '\u{209c}'), ('\u{2102}', '\u{2102}'), ('\u{2107}', '\u{2107}'), ('\u{210a}',
- '\u{2113}'), ('\u{2115}', '\u{2115}'), ('\u{2118}', '\u{211d}'), ('\u{2124}', '\u{2124}'),
- ('\u{2126}', '\u{2126}'), ('\u{2128}', '\u{2128}'), ('\u{212a}', '\u{2139}'), ('\u{213c}',
- '\u{213f}'), ('\u{2145}', '\u{2149}'), ('\u{214e}', '\u{214e}'), ('\u{2160}', '\u{2188}'),
- ('\u{2c00}', '\u{2c2e}'), ('\u{2c30}', '\u{2c5e}'), ('\u{2c60}', '\u{2ce4}'), ('\u{2ceb}',
- '\u{2cee}'), ('\u{2cf2}', '\u{2cf3}'), ('\u{2d00}', '\u{2d25}'), ('\u{2d27}', '\u{2d27}'),
- ('\u{2d2d}', '\u{2d2d}'), ('\u{2d30}', '\u{2d67}'), ('\u{2d6f}', '\u{2d6f}'), ('\u{2d80}',
- '\u{2d96}'), ('\u{2da0}', '\u{2da6}'), ('\u{2da8}', '\u{2dae}'), ('\u{2db0}', '\u{2db6}'),
- ('\u{2db8}', '\u{2dbe}'), ('\u{2dc0}', '\u{2dc6}'), ('\u{2dc8}', '\u{2dce}'), ('\u{2dd0}',
- '\u{2dd6}'), ('\u{2dd8}', '\u{2dde}'), ('\u{3005}', '\u{3007}'), ('\u{3021}', '\u{3029}'),
- ('\u{3031}', '\u{3035}'), ('\u{3038}', '\u{303c}'), ('\u{3041}', '\u{3096}'), ('\u{309d}',
- '\u{309f}'), ('\u{30a1}', '\u{30fa}'), ('\u{30fc}', '\u{30ff}'), ('\u{3105}', '\u{312d}'),
- ('\u{3131}', '\u{318e}'), ('\u{31a0}', '\u{31ba}'), ('\u{31f0}', '\u{31ff}'), ('\u{3400}',
- '\u{4db5}'), ('\u{4e00}', '\u{9fd5}'), ('\u{a000}', '\u{a48c}'), ('\u{a4d0}', '\u{a4fd}'),
- ('\u{a500}', '\u{a60c}'), ('\u{a610}', '\u{a61f}'), ('\u{a62a}', '\u{a62b}'), ('\u{a640}',
- '\u{a66e}'), ('\u{a67f}', '\u{a69d}'), ('\u{a6a0}', '\u{a6ef}'), ('\u{a717}', '\u{a71f}'),
- ('\u{a722}', '\u{a788}'), ('\u{a78b}', '\u{a7ae}'), ('\u{a7b0}', '\u{a7b7}'), ('\u{a7f7}',
- '\u{a801}'), ('\u{a803}', '\u{a805}'), ('\u{a807}', '\u{a80a}'), ('\u{a80c}', '\u{a822}'),
- ('\u{a840}', '\u{a873}'), ('\u{a882}', '\u{a8b3}'), ('\u{a8f2}', '\u{a8f7}'), ('\u{a8fb}',
- '\u{a8fb}'), ('\u{a8fd}', '\u{a8fd}'), ('\u{a90a}', '\u{a925}'), ('\u{a930}', '\u{a946}'),
- ('\u{a960}', '\u{a97c}'), ('\u{a984}', '\u{a9b2}'), ('\u{a9cf}', '\u{a9cf}'), ('\u{a9e0}',
- '\u{a9e4}'), ('\u{a9e6}', '\u{a9ef}'), ('\u{a9fa}', '\u{a9fe}'), ('\u{aa00}', '\u{aa28}'),
- ('\u{aa40}', '\u{aa42}'), ('\u{aa44}', '\u{aa4b}'), ('\u{aa60}', '\u{aa76}'), ('\u{aa7a}',
- '\u{aa7a}'), ('\u{aa7e}', '\u{aaaf}'), ('\u{aab1}', '\u{aab1}'), ('\u{aab5}', '\u{aab6}'),
- ('\u{aab9}', '\u{aabd}'), ('\u{aac0}', '\u{aac0}'), ('\u{aac2}', '\u{aac2}'), ('\u{aadb}',
- '\u{aadd}'), ('\u{aae0}', '\u{aaea}'), ('\u{aaf2}', '\u{aaf4}'), ('\u{ab01}', '\u{ab06}'),
- ('\u{ab09}', '\u{ab0e}'), ('\u{ab11}', '\u{ab16}'), ('\u{ab20}', '\u{ab26}'), ('\u{ab28}',
- '\u{ab2e}'), ('\u{ab30}', '\u{ab5a}'), ('\u{ab5c}', '\u{ab65}'), ('\u{ab70}', '\u{abe2}'),
- ('\u{ac00}', '\u{d7a3}'), ('\u{d7b0}', '\u{d7c6}'), ('\u{d7cb}', '\u{d7fb}'), ('\u{f900}',
- '\u{fa6d}'), ('\u{fa70}', '\u{fad9}'), ('\u{fb00}', '\u{fb06}'), ('\u{fb13}', '\u{fb17}'),
- ('\u{fb1d}', '\u{fb1d}'), ('\u{fb1f}', '\u{fb28}'), ('\u{fb2a}', '\u{fb36}'), ('\u{fb38}',
- '\u{fb3c}'), ('\u{fb3e}', '\u{fb3e}'), ('\u{fb40}', '\u{fb41}'), ('\u{fb43}', '\u{fb44}'),
- ('\u{fb46}', '\u{fbb1}'), ('\u{fbd3}', '\u{fc5d}'), ('\u{fc64}', '\u{fd3d}'), ('\u{fd50}',
- '\u{fd8f}'), ('\u{fd92}', '\u{fdc7}'), ('\u{fdf0}', '\u{fdf9}'), ('\u{fe71}', '\u{fe71}'),
- ('\u{fe73}', '\u{fe73}'), ('\u{fe77}', '\u{fe77}'), ('\u{fe79}', '\u{fe79}'), ('\u{fe7b}',
- '\u{fe7b}'), ('\u{fe7d}', '\u{fe7d}'), ('\u{fe7f}', '\u{fefc}'), ('\u{ff21}', '\u{ff3a}'),
- ('\u{ff41}', '\u{ff5a}'), ('\u{ff66}', '\u{ff9d}'), ('\u{ffa0}', '\u{ffbe}'), ('\u{ffc2}',
- '\u{ffc7}'), ('\u{ffca}', '\u{ffcf}'), ('\u{ffd2}', '\u{ffd7}'), ('\u{ffda}', '\u{ffdc}'),
- ('\u{10000}', '\u{1000b}'), ('\u{1000d}', '\u{10026}'), ('\u{10028}', '\u{1003a}'),
- ('\u{1003c}', '\u{1003d}'), ('\u{1003f}', '\u{1004d}'), ('\u{10050}', '\u{1005d}'),
- ('\u{10080}', '\u{100fa}'), ('\u{10140}', '\u{10174}'), ('\u{10280}', '\u{1029c}'),
- ('\u{102a0}', '\u{102d0}'), ('\u{10300}', '\u{1031f}'), ('\u{10330}', '\u{1034a}'),
- ('\u{10350}', '\u{10375}'), ('\u{10380}', '\u{1039d}'), ('\u{103a0}', '\u{103c3}'),
- ('\u{103c8}', '\u{103cf}'), ('\u{103d1}', '\u{103d5}'), ('\u{10400}', '\u{1049d}'),
- ('\u{104b0}', '\u{104d3}'), ('\u{104d8}', '\u{104fb}'), ('\u{10500}', '\u{10527}'),
- ('\u{10530}', '\u{10563}'), ('\u{10600}', '\u{10736}'), ('\u{10740}', '\u{10755}'),
- ('\u{10760}', '\u{10767}'), ('\u{10800}', '\u{10805}'), ('\u{10808}', '\u{10808}'),
- ('\u{1080a}', '\u{10835}'), ('\u{10837}', '\u{10838}'), ('\u{1083c}', '\u{1083c}'),
- ('\u{1083f}', '\u{10855}'), ('\u{10860}', '\u{10876}'), ('\u{10880}', '\u{1089e}'),
- ('\u{108e0}', '\u{108f2}'), ('\u{108f4}', '\u{108f5}'), ('\u{10900}', '\u{10915}'),
- ('\u{10920}', '\u{10939}'), ('\u{10980}', '\u{109b7}'), ('\u{109be}', '\u{109bf}'),
- ('\u{10a00}', '\u{10a00}'), ('\u{10a10}', '\u{10a13}'), ('\u{10a15}', '\u{10a17}'),
- ('\u{10a19}', '\u{10a33}'), ('\u{10a60}', '\u{10a7c}'), ('\u{10a80}', '\u{10a9c}'),
- ('\u{10ac0}', '\u{10ac7}'), ('\u{10ac9}', '\u{10ae4}'), ('\u{10b00}', '\u{10b35}'),
- ('\u{10b40}', '\u{10b55}'), ('\u{10b60}', '\u{10b72}'), ('\u{10b80}', '\u{10b91}'),
- ('\u{10c00}', '\u{10c48}'), ('\u{10c80}', '\u{10cb2}'), ('\u{10cc0}', '\u{10cf2}'),
- ('\u{11003}', '\u{11037}'), ('\u{11083}', '\u{110af}'), ('\u{110d0}', '\u{110e8}'),
- ('\u{11103}', '\u{11126}'), ('\u{11150}', '\u{11172}'), ('\u{11176}', '\u{11176}'),
- ('\u{11183}', '\u{111b2}'), ('\u{111c1}', '\u{111c4}'), ('\u{111da}', '\u{111da}'),
- ('\u{111dc}', '\u{111dc}'), ('\u{11200}', '\u{11211}'), ('\u{11213}', '\u{1122b}'),
- ('\u{11280}', '\u{11286}'), ('\u{11288}', '\u{11288}'), ('\u{1128a}', '\u{1128d}'),
- ('\u{1128f}', '\u{1129d}'), ('\u{1129f}', '\u{112a8}'), ('\u{112b0}', '\u{112de}'),
- ('\u{11305}', '\u{1130c}'), ('\u{1130f}', '\u{11310}'), ('\u{11313}', '\u{11328}'),
- ('\u{1132a}', '\u{11330}'), ('\u{11332}', '\u{11333}'), ('\u{11335}', '\u{11339}'),
- ('\u{1133d}', '\u{1133d}'), ('\u{11350}', '\u{11350}'), ('\u{1135d}', '\u{11361}'),
- ('\u{11400}', '\u{11434}'), ('\u{11447}', '\u{1144a}'), ('\u{11480}', '\u{114af}'),
- ('\u{114c4}', '\u{114c5}'), ('\u{114c7}', '\u{114c7}'), ('\u{11580}', '\u{115ae}'),
- ('\u{115d8}', '\u{115db}'), ('\u{11600}', '\u{1162f}'), ('\u{11644}', '\u{11644}'),
- ('\u{11680}', '\u{116aa}'), ('\u{11700}', '\u{11719}'), ('\u{118a0}', '\u{118df}'),
- ('\u{118ff}', '\u{118ff}'), ('\u{11ac0}', '\u{11af8}'), ('\u{11c00}', '\u{11c08}'),
- ('\u{11c0a}', '\u{11c2e}'), ('\u{11c40}', '\u{11c40}'), ('\u{11c72}', '\u{11c8f}'),
- ('\u{12000}', '\u{12399}'), ('\u{12400}', '\u{1246e}'), ('\u{12480}', '\u{12543}'),
- ('\u{13000}', '\u{1342e}'), ('\u{14400}', '\u{14646}'), ('\u{16800}', '\u{16a38}'),
- ('\u{16a40}', '\u{16a5e}'), ('\u{16ad0}', '\u{16aed}'), ('\u{16b00}', '\u{16b2f}'),
- ('\u{16b40}', '\u{16b43}'), ('\u{16b63}', '\u{16b77}'), ('\u{16b7d}', '\u{16b8f}'),
- ('\u{16f00}', '\u{16f44}'), ('\u{16f50}', '\u{16f50}'), ('\u{16f93}', '\u{16f9f}'),
- ('\u{16fe0}', '\u{16fe0}'), ('\u{17000}', '\u{187ec}'), ('\u{18800}', '\u{18af2}'),
- ('\u{1b000}', '\u{1b001}'), ('\u{1bc00}', '\u{1bc6a}'), ('\u{1bc70}', '\u{1bc7c}'),
- ('\u{1bc80}', '\u{1bc88}'), ('\u{1bc90}', '\u{1bc99}'), ('\u{1d400}', '\u{1d454}'),
- ('\u{1d456}', '\u{1d49c}'), ('\u{1d49e}', '\u{1d49f}'), ('\u{1d4a2}', '\u{1d4a2}'),
- ('\u{1d4a5}', '\u{1d4a6}'), ('\u{1d4a9}', '\u{1d4ac}'), ('\u{1d4ae}', '\u{1d4b9}'),
- ('\u{1d4bb}', '\u{1d4bb}'), ('\u{1d4bd}', '\u{1d4c3}'), ('\u{1d4c5}', '\u{1d505}'),
- ('\u{1d507}', '\u{1d50a}'), ('\u{1d50d}', '\u{1d514}'), ('\u{1d516}', '\u{1d51c}'),
- ('\u{1d51e}', '\u{1d539}'), ('\u{1d53b}', '\u{1d53e}'), ('\u{1d540}', '\u{1d544}'),
- ('\u{1d546}', '\u{1d546}'), ('\u{1d54a}', '\u{1d550}'), ('\u{1d552}', '\u{1d6a5}'),
- ('\u{1d6a8}', '\u{1d6c0}'), ('\u{1d6c2}', '\u{1d6da}'), ('\u{1d6dc}', '\u{1d6fa}'),
- ('\u{1d6fc}', '\u{1d714}'), ('\u{1d716}', '\u{1d734}'), ('\u{1d736}', '\u{1d74e}'),
- ('\u{1d750}', '\u{1d76e}'), ('\u{1d770}', '\u{1d788}'), ('\u{1d78a}', '\u{1d7a8}'),
- ('\u{1d7aa}', '\u{1d7c2}'), ('\u{1d7c4}', '\u{1d7cb}'), ('\u{1e800}', '\u{1e8c4}'),
- ('\u{1e900}', '\u{1e943}'), ('\u{1ee00}', '\u{1ee03}'), ('\u{1ee05}', '\u{1ee1f}'),
- ('\u{1ee21}', '\u{1ee22}'), ('\u{1ee24}', '\u{1ee24}'), ('\u{1ee27}', '\u{1ee27}'),
- ('\u{1ee29}', '\u{1ee32}'), ('\u{1ee34}', '\u{1ee37}'), ('\u{1ee39}', '\u{1ee39}'),
- ('\u{1ee3b}', '\u{1ee3b}'), ('\u{1ee42}', '\u{1ee42}'), ('\u{1ee47}', '\u{1ee47}'),
- ('\u{1ee49}', '\u{1ee49}'), ('\u{1ee4b}', '\u{1ee4b}'), ('\u{1ee4d}', '\u{1ee4f}'),
- ('\u{1ee51}', '\u{1ee52}'), ('\u{1ee54}', '\u{1ee54}'), ('\u{1ee57}', '\u{1ee57}'),
- ('\u{1ee59}', '\u{1ee59}'), ('\u{1ee5b}', '\u{1ee5b}'), ('\u{1ee5d}', '\u{1ee5d}'),
- ('\u{1ee5f}', '\u{1ee5f}'), ('\u{1ee61}', '\u{1ee62}'), ('\u{1ee64}', '\u{1ee64}'),
- ('\u{1ee67}', '\u{1ee6a}'), ('\u{1ee6c}', '\u{1ee72}'), ('\u{1ee74}', '\u{1ee77}'),
- ('\u{1ee79}', '\u{1ee7c}'), ('\u{1ee7e}', '\u{1ee7e}'), ('\u{1ee80}', '\u{1ee89}'),
- ('\u{1ee8b}', '\u{1ee9b}'), ('\u{1eea1}', '\u{1eea3}'), ('\u{1eea5}', '\u{1eea9}'),
- ('\u{1eeab}', '\u{1eebb}'), ('\u{20000}', '\u{2a6d6}'), ('\u{2a700}', '\u{2b734}'),
- ('\u{2b740}', '\u{2b81d}'), ('\u{2b820}', '\u{2cea1}'), ('\u{2f800}', '\u{2fa1d}')
- ];
-
- pub fn XID_Start(c: char) -> bool {
- super::bsearch_range_table(c, XID_Start_table)
- }
-
-}
-
deleted file mode 100644
--- a/third_party/rust/unicode-xid-0.0.4/src/tests.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// 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.
-
-#[cfg(feature = "bench")]
-use std::iter;
-#[cfg(feature = "bench")]
-use test::Bencher;
-#[cfg(feature = "bench")]
-use std::prelude::v1::*;
-
-use super::UnicodeXID;
-
-#[cfg(feature = "bench")]
-#[bench]
-fn cargo_is_xid_start(b: &mut Bencher) {
- let string = iter::repeat('a').take(4096).collect::<String>();
-
- b.bytes = string.len() as u64;
- b.iter(|| {
- string.chars().all(UnicodeXID::is_xid_start)
- });
-}
-
-#[cfg(feature = "bench")]
-#[bench]
-fn stdlib_is_xid_start(b: &mut Bencher) {
- let string = iter::repeat('a').take(4096).collect::<String>();
-
- b.bytes = string.len() as u64;
- b.iter(|| {
- string.chars().all(char::is_xid_start)
- });
-}
-
-#[cfg(feature = "bench")]
-#[bench]
-fn cargo_xid_continue(b: &mut Bencher) {
- let string = iter::repeat('a').take(4096).collect::<String>();
-
- b.bytes = string.len() as u64;
- b.iter(|| {
- string.chars().all(UnicodeXID::is_xid_continue)
- });
-}
-
-#[cfg(feature = "bench")]
-#[bench]
-fn stdlib_xid_continue(b: &mut Bencher) {
- let string = iter::repeat('a').take(4096).collect::<String>();
-
- b.bytes = string.len() as u64;
- b.iter(|| {
- string.chars().all(char::is_xid_continue)
- });
-}
-
-#[test]
-fn test_is_xid_start() {
- let chars = [
- 'A', 'Z', 'a', 'z',
- '\u{1000d}', '\u{10026}',
- ];
-
- for ch in &chars {
- assert!(UnicodeXID::is_xid_start(*ch), "{}", ch);
- }
-}
-
-#[test]
-fn test_is_not_xid_start() {
- let chars = [
- '\x00', '\x01',
- '0', '9',
- ' ', '[', '<', '{', '(',
- '\u{02c2}', '\u{ffff}',
- ];
-
- for ch in &chars {
- assert!(!UnicodeXID::is_xid_start(*ch), "{}", ch);
- }
-}
-
-#[test]
-fn test_is_xid_continue() {
- let chars = [
- '0', '9', 'A', 'Z', 'a', 'z', '_',
- '\u{1000d}', '\u{10026}',
- ];
-
- for ch in &chars {
- assert!(UnicodeXID::is_xid_continue(*ch), "{}", ch);
- }
-}
-
-#[test]
-fn test_is_not_xid_continue() {
- let chars = [
- '\x00', '\x01',
- ' ', '[', '<', '{', '(',
- '\u{02c2}', '\u{ffff}',
- ];
-
- for &ch in &chars {
- assert!(!UnicodeXID::is_xid_continue(ch), "{}", ch);
- }
-}