woops
This commit is contained in:
parent
51be5dcf55
commit
1453885ed2
GPG key ID:
BDA47A31A3C8EE6B
50 changed files with 17263 additions and 1 deletions
|
|
@ -1 +0,0 @@
|
||||||
Subproject commit dff506bb8a83702e2dc82b17177dda43e6de0f3a
|
|
||||||
22
syn-serde/.editorconfig
Normal file
22
syn-serde/.editorconfig
Normal file
|
|
@ -0,0 +1,22 @@
|
||||||
|
# EditorConfig configuration
|
||||||
|
# https://editorconfig.org
|
||||||
|
|
||||||
|
# Top-most EditorConfig file
|
||||||
|
root = true
|
||||||
|
|
||||||
|
# Unix-style newlines with a newline ending every file, utf-8 charset
|
||||||
|
[*]
|
||||||
|
end_of_line = lf
|
||||||
|
insert_final_newline = true
|
||||||
|
trim_trailing_whitespace = true
|
||||||
|
charset = utf-8
|
||||||
|
|
||||||
|
# Match rust/toml, set 4 space indentation
|
||||||
|
[*.{rs,toml}]
|
||||||
|
indent_style = space
|
||||||
|
indent_size = 4
|
||||||
|
|
||||||
|
# Match json/yaml/markdown, set 2 space indentation
|
||||||
|
[*.{json,yml,md}]
|
||||||
|
indent_style = space
|
||||||
|
indent_size = 2
|
||||||
4
syn-serde/.gitattributes
vendored
Normal file
4
syn-serde/.gitattributes
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
||||||
|
[attr]rust text eol=lf whitespace=tab-in-indent,trailing-space,tabwidth=4
|
||||||
|
|
||||||
|
* text=auto eol=lf
|
||||||
|
*.rs rust
|
||||||
1
syn-serde/.github/CODEOWNERS
vendored
Normal file
1
syn-serde/.github/CODEOWNERS
vendored
Normal file
|
|
@ -0,0 +1 @@
|
||||||
|
* @taiki-e
|
||||||
10
syn-serde/.github/bors.toml
vendored
Normal file
10
syn-serde/.github/bors.toml
vendored
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
status = [
|
||||||
|
"test (1.31.0)",
|
||||||
|
"test (stable)",
|
||||||
|
"test (beta)",
|
||||||
|
"test (nightly)",
|
||||||
|
"style (clippy)",
|
||||||
|
"style (rustfmt)",
|
||||||
|
"style (rustdoc)",
|
||||||
|
]
|
||||||
|
delete_merged_branches = true
|
||||||
95
syn-serde/.github/workflows/ci.yml
vendored
Normal file
95
syn-serde/.github/workflows/ci.yml
vendored
Normal file
|
|
@ -0,0 +1,95 @@
|
||||||
|
name: ci
|
||||||
|
|
||||||
|
on:
|
||||||
|
pull_request:
|
||||||
|
push:
|
||||||
|
branches:
|
||||||
|
- master
|
||||||
|
- staging
|
||||||
|
- trying
|
||||||
|
schedule:
|
||||||
|
- cron: '00 01 * * *'
|
||||||
|
|
||||||
|
env:
|
||||||
|
RUSTFLAGS: -Dwarnings
|
||||||
|
|
||||||
|
jobs:
|
||||||
|
test:
|
||||||
|
name: test
|
||||||
|
runs-on: ubuntu-latest
|
||||||
|
strategy:
|
||||||
|
matrix:
|
||||||
|
rust:
|
||||||
|
# This is the minimum supported Rust version of this crate.
|
||||||
|
# When updating this, the reminder to update the minimum supported
|
||||||
|
# Rust version in README.md.
|
||||||
|
#
|
||||||
|
# Tests are not run as tests may require newer versions of Rust.
|
||||||
|
- 1.31.0
|
||||||
|
- stable
|
||||||
|
- beta
|
||||||
|
- nightly
|
||||||
|
steps:
|
||||||
|
- uses: actions/checkout@master
|
||||||
|
- name: Install Rust
|
||||||
|
shell: bash
|
||||||
|
run: |
|
||||||
|
. ./ci/install-rust.sh ${{ matrix.rust }}
|
||||||
|
- name: Install cargo-hack
|
||||||
|
if: matrix.rust != '1.31.0'
|
||||||
|
run: |
|
||||||
|
cargo install cargo-hack
|
||||||
|
- name: cargo check
|
||||||
|
if: matrix.rust == '1.31.0'
|
||||||
|
run: |
|
||||||
|
cargo check --all-features
|
||||||
|
- name: cargo test
|
||||||
|
if: matrix.rust != '1.31.0'
|
||||||
|
run: |
|
||||||
|
cargo test --all-features
|
||||||
|
- name: cargo hack check --each-feature
|
||||||
|
if: matrix.rust != '1.31.0'
|
||||||
|
run: |
|
||||||
|
cargo hack check --all --each-feature --no-dev-deps
|
||||||
|
# Refs: https://github.com/rust-lang/cargo/issues/5657
|
||||||
|
- name: cargo check -Zminimal-versions
|
||||||
|
if: matrix.rust == 'nightly'
|
||||||
|
run: |
|
||||||
|
cargo update -Zminimal-versions
|
||||||
|
cargo hack check --all --all-features --no-dev-deps --ignore-private
|
||||||
|
|
||||||
|
style:
|
||||||
|
name: style
|
||||||
|
runs-on: ubuntu-latest
|
||||||
|
strategy:
|
||||||
|
fail-fast: false
|
||||||
|
matrix:
|
||||||
|
component:
|
||||||
|
- clippy
|
||||||
|
- rustfmt
|
||||||
|
- rustdoc
|
||||||
|
steps:
|
||||||
|
- uses: actions/checkout@master
|
||||||
|
- name: Install Rust
|
||||||
|
shell: bash
|
||||||
|
run: |
|
||||||
|
. ./ci/install-rust.sh
|
||||||
|
- name: Install component
|
||||||
|
if: matrix.component != 'rustdoc'
|
||||||
|
shell: bash
|
||||||
|
run: |
|
||||||
|
. ./ci/install-component.sh ${{ matrix.component }}
|
||||||
|
- name: cargo clippy
|
||||||
|
if: matrix.component == 'clippy'
|
||||||
|
run: |
|
||||||
|
cargo clippy --all --all-features --all-targets
|
||||||
|
- name: cargo fmt -- --check
|
||||||
|
if: matrix.component == 'rustfmt'
|
||||||
|
run: |
|
||||||
|
cargo fmt --all -- --check
|
||||||
|
- name: cargo doc
|
||||||
|
if: matrix.component == 'rustdoc'
|
||||||
|
env:
|
||||||
|
RUSTDOCFLAGS: -Dwarnings
|
||||||
|
run: |
|
||||||
|
cargo doc --no-deps --all --all-features
|
||||||
7
syn-serde/.gitignore
vendored
Normal file
7
syn-serde/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
target
|
||||||
|
**/*.rs.bk
|
||||||
|
Cargo.lock
|
||||||
|
|
||||||
|
# For platform and editor specific settings, it is recommended to add to
|
||||||
|
# a global .gitignore file.
|
||||||
|
# Refs: https://help.github.com/en/articles/ignoring-files#create-a-global-gitignore
|
||||||
21
syn-serde/CHANGELOG.md
Normal file
21
syn-serde/CHANGELOG.md
Normal file
|
|
@ -0,0 +1,21 @@
|
||||||
|
# Changelog
|
||||||
|
|
||||||
|
All notable changes to this project will be documented in this file.
|
||||||
|
|
||||||
|
This project adheres to [Semantic Versioning](https://semver.org).
|
||||||
|
|
||||||
|
## [Unreleased]
|
||||||
|
|
||||||
|
# [0.2.0] - 2019-09-16
|
||||||
|
|
||||||
|
* [Removed error from `to_string` / `to_vec`.][e949263]
|
||||||
|
|
||||||
|
[e949263]: https://github.com/taiki-e/syn-serde/commit/e9492636eb7d58565fc415e55fd824b06b37f3d3
|
||||||
|
|
||||||
|
# [0.1.0] - 2019-09-16
|
||||||
|
|
||||||
|
Initial release
|
||||||
|
|
||||||
|
[Unreleased]: https://github.com/taiki-e/syn-serde/compare/v0.2.0...HEAD
|
||||||
|
[0.2.0]: https://github.com/taiki-e/syn-serde/compare/v0.1.0...v0.2.0
|
||||||
|
[0.1.0]: https://github.com/taiki-e/syn-serde/releases/tag/v0.1.0
|
||||||
36
syn-serde/Cargo.toml
Normal file
36
syn-serde/Cargo.toml
Normal file
|
|
@ -0,0 +1,36 @@
|
||||||
|
[package]
|
||||||
|
name = "syn-serde"
|
||||||
|
version = "0.2.0"
|
||||||
|
authors = ["David Tolnay <dtolnay@gmail.com>", "Taiki Endo <te316e89@gmail.com>"]
|
||||||
|
edition = "2018"
|
||||||
|
license = "Apache-2.0 OR MIT"
|
||||||
|
repository = "https://github.com/taiki-e/syn-serde"
|
||||||
|
homepage = "https://github.com/taiki-e/syn-serde"
|
||||||
|
documentation = "https://docs.rs/syn-serde"
|
||||||
|
keywords = ["serde", "serialization", "syn"]
|
||||||
|
categories = ["development-tools::procedural-macro-helpers", "encoding"]
|
||||||
|
readme = "README.md"
|
||||||
|
description = """
|
||||||
|
Library to serialize and deserialize Syn syntax trees.
|
||||||
|
"""
|
||||||
|
|
||||||
|
[features]
|
||||||
|
json = ["serde_json"]
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
proc-macro2 = { version = "1.0", default-features = false }
|
||||||
|
serde = { version = "1.0.99", features = ["derive"] }
|
||||||
|
serde_derive = "1.0.99" # This is necessary to make `-Z minimal-versions` build successful.
|
||||||
|
serde_json = { version = "1.0", optional = true }
|
||||||
|
syn = { version = "1.0.5", default-features = false, features = ["full"] }
|
||||||
|
|
||||||
|
[dev-dependencies]
|
||||||
|
quote = "1.0"
|
||||||
|
serde_json = "1.0"
|
||||||
|
syn = { version = "1.0", features = ["full", "extra-traits"] }
|
||||||
|
|
||||||
|
[package.metadata.docs.rs]
|
||||||
|
all-features = true
|
||||||
|
|
||||||
|
[package.metadata.playground]
|
||||||
|
all-features = true
|
||||||
201
syn-serde/LICENSE-APACHE
Normal file
201
syn-serde/LICENSE-APACHE
Normal file
|
|
@ -0,0 +1,201 @@
|
||||||
|
Apache License
|
||||||
|
Version 2.0, January 2004
|
||||||
|
http://www.apache.org/licenses/
|
||||||
|
|
||||||
|
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||||
|
|
||||||
|
1. Definitions.
|
||||||
|
|
||||||
|
"License" shall mean the terms and conditions for use, reproduction,
|
||||||
|
and distribution as defined by Sections 1 through 9 of this document.
|
||||||
|
|
||||||
|
"Licensor" shall mean the copyright owner or entity authorized by
|
||||||
|
the copyright owner that is granting the License.
|
||||||
|
|
||||||
|
"Legal Entity" shall mean the union of the acting entity and all
|
||||||
|
other entities that control, are controlled by, or are under common
|
||||||
|
control with that entity. For the purposes of this definition,
|
||||||
|
"control" means (i) the power, direct or indirect, to cause the
|
||||||
|
direction or management of such entity, whether by contract or
|
||||||
|
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||||
|
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||||
|
|
||||||
|
"You" (or "Your") shall mean an individual or Legal Entity
|
||||||
|
exercising permissions granted by this License.
|
||||||
|
|
||||||
|
"Source" form shall mean the preferred form for making modifications,
|
||||||
|
including but not limited to software source code, documentation
|
||||||
|
source, and configuration files.
|
||||||
|
|
||||||
|
"Object" form shall mean any form resulting from mechanical
|
||||||
|
transformation or translation of a Source form, including but
|
||||||
|
not limited to compiled object code, generated documentation,
|
||||||
|
and conversions to other media types.
|
||||||
|
|
||||||
|
"Work" shall mean the work of authorship, whether in Source or
|
||||||
|
Object form, made available under the License, as indicated by a
|
||||||
|
copyright notice that is included in or attached to the work
|
||||||
|
(an example is provided in the Appendix below).
|
||||||
|
|
||||||
|
"Derivative Works" shall mean any work, whether in Source or Object
|
||||||
|
form, that is based on (or derived from) the Work and for which the
|
||||||
|
editorial revisions, annotations, elaborations, or other modifications
|
||||||
|
represent, as a whole, an original work of authorship. For the purposes
|
||||||
|
of this License, Derivative Works shall not include works that remain
|
||||||
|
separable from, or merely link (or bind by name) to the interfaces of,
|
||||||
|
the Work and Derivative Works thereof.
|
||||||
|
|
||||||
|
"Contribution" shall mean any work of authorship, including
|
||||||
|
the original version of the Work and any modifications or additions
|
||||||
|
to that Work or Derivative Works thereof, that is intentionally
|
||||||
|
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||||
|
or by an individual or Legal Entity authorized to submit on behalf of
|
||||||
|
the copyright owner. For the purposes of this definition, "submitted"
|
||||||
|
means any form of electronic, verbal, or written communication sent
|
||||||
|
to the Licensor or its representatives, including but not limited to
|
||||||
|
communication on electronic mailing lists, source code control systems,
|
||||||
|
and issue tracking systems that are managed by, or on behalf of, the
|
||||||
|
Licensor for the purpose of discussing and improving the Work, but
|
||||||
|
excluding communication that is conspicuously marked or otherwise
|
||||||
|
designated in writing by the copyright owner as "Not a Contribution."
|
||||||
|
|
||||||
|
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||||
|
on behalf of whom a Contribution has been received by Licensor and
|
||||||
|
subsequently incorporated within the Work.
|
||||||
|
|
||||||
|
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||||
|
this License, each Contributor hereby grants to You a perpetual,
|
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||||
|
copyright license to reproduce, prepare Derivative Works of,
|
||||||
|
publicly display, publicly perform, sublicense, and distribute the
|
||||||
|
Work and such Derivative Works in Source or Object form.
|
||||||
|
|
||||||
|
3. Grant of Patent License. Subject to the terms and conditions of
|
||||||
|
this License, each Contributor hereby grants to You a perpetual,
|
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||||
|
(except as stated in this section) patent license to make, have made,
|
||||||
|
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||||
|
where such license applies only to those patent claims licensable
|
||||||
|
by such Contributor that are necessarily infringed by their
|
||||||
|
Contribution(s) alone or by combination of their Contribution(s)
|
||||||
|
with the Work to which such Contribution(s) was submitted. If You
|
||||||
|
institute patent litigation against any entity (including a
|
||||||
|
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||||
|
or a Contribution incorporated within the Work constitutes direct
|
||||||
|
or contributory patent infringement, then any patent licenses
|
||||||
|
granted to You under this License for that Work shall terminate
|
||||||
|
as of the date such litigation is filed.
|
||||||
|
|
||||||
|
4. Redistribution. You may reproduce and distribute copies of the
|
||||||
|
Work or Derivative Works thereof in any medium, with or without
|
||||||
|
modifications, and in Source or Object form, provided that You
|
||||||
|
meet the following conditions:
|
||||||
|
|
||||||
|
(a) You must give any other recipients of the Work or
|
||||||
|
Derivative Works a copy of this License; and
|
||||||
|
|
||||||
|
(b) You must cause any modified files to carry prominent notices
|
||||||
|
stating that You changed the files; and
|
||||||
|
|
||||||
|
(c) You must retain, in the Source form of any Derivative Works
|
||||||
|
that You distribute, all copyright, patent, trademark, and
|
||||||
|
attribution notices from the Source form of the Work,
|
||||||
|
excluding those notices that do not pertain to any part of
|
||||||
|
the Derivative Works; and
|
||||||
|
|
||||||
|
(d) If the Work includes a "NOTICE" text file as part of its
|
||||||
|
distribution, then any Derivative Works that You distribute must
|
||||||
|
include a readable copy of the attribution notices contained
|
||||||
|
within such NOTICE file, excluding those notices that do not
|
||||||
|
pertain to any part of the Derivative Works, in at least one
|
||||||
|
of the following places: within a NOTICE text file distributed
|
||||||
|
as part of the Derivative Works; within the Source form or
|
||||||
|
documentation, if provided along with the Derivative Works; or,
|
||||||
|
within a display generated by the Derivative Works, if and
|
||||||
|
wherever such third-party notices normally appear. The contents
|
||||||
|
of the NOTICE file are for informational purposes only and
|
||||||
|
do not modify the License. You may add Your own attribution
|
||||||
|
notices within Derivative Works that You distribute, alongside
|
||||||
|
or as an addendum to the NOTICE text from the Work, provided
|
||||||
|
that such additional attribution notices cannot be construed
|
||||||
|
as modifying the License.
|
||||||
|
|
||||||
|
You may add Your own copyright statement to Your modifications and
|
||||||
|
may provide additional or different license terms and conditions
|
||||||
|
for use, reproduction, or distribution of Your modifications, or
|
||||||
|
for any such Derivative Works as a whole, provided Your use,
|
||||||
|
reproduction, and distribution of the Work otherwise complies with
|
||||||
|
the conditions stated in this License.
|
||||||
|
|
||||||
|
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||||
|
any Contribution intentionally submitted for inclusion in the Work
|
||||||
|
by You to the Licensor shall be under the terms and conditions of
|
||||||
|
this License, without any additional terms or conditions.
|
||||||
|
Notwithstanding the above, nothing herein shall supersede or modify
|
||||||
|
the terms of any separate license agreement you may have executed
|
||||||
|
with Licensor regarding such Contributions.
|
||||||
|
|
||||||
|
6. Trademarks. This License does not grant permission to use the trade
|
||||||
|
names, trademarks, service marks, or product names of the Licensor,
|
||||||
|
except as required for reasonable and customary use in describing the
|
||||||
|
origin of the Work and reproducing the content of the NOTICE file.
|
||||||
|
|
||||||
|
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||||
|
agreed to in writing, Licensor provides the Work (and each
|
||||||
|
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||||
|
implied, including, without limitation, any warranties or conditions
|
||||||
|
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||||
|
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||||
|
appropriateness of using or redistributing the Work and assume any
|
||||||
|
risks associated with Your exercise of permissions under this License.
|
||||||
|
|
||||||
|
8. Limitation of Liability. In no event and under no legal theory,
|
||||||
|
whether in tort (including negligence), contract, or otherwise,
|
||||||
|
unless required by applicable law (such as deliberate and grossly
|
||||||
|
negligent acts) or agreed to in writing, shall any Contributor be
|
||||||
|
liable to You for damages, including any direct, indirect, special,
|
||||||
|
incidental, or consequential damages of any character arising as a
|
||||||
|
result of this License or out of the use or inability to use the
|
||||||
|
Work (including but not limited to damages for loss of goodwill,
|
||||||
|
work stoppage, computer failure or malfunction, or any and all
|
||||||
|
other commercial damages or losses), even if such Contributor
|
||||||
|
has been advised of the possibility of such damages.
|
||||||
|
|
||||||
|
9. Accepting Warranty or Additional Liability. While redistributing
|
||||||
|
the Work or Derivative Works thereof, You may choose to offer,
|
||||||
|
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||||
|
or other liability obligations and/or rights consistent with this
|
||||||
|
License. However, in accepting such obligations, You may act only
|
||||||
|
on Your own behalf and on Your sole responsibility, not on behalf
|
||||||
|
of any other Contributor, and only if You agree to indemnify,
|
||||||
|
defend, and hold each Contributor harmless for any liability
|
||||||
|
incurred by, or claims asserted against, such Contributor by reason
|
||||||
|
of your accepting any such warranty or additional liability.
|
||||||
|
|
||||||
|
END OF TERMS AND CONDITIONS
|
||||||
|
|
||||||
|
APPENDIX: How to apply the Apache License to your work.
|
||||||
|
|
||||||
|
To apply the Apache License to your work, attach the following
|
||||||
|
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||||
|
replaced with your own identifying information. (Don't include
|
||||||
|
the brackets!) The text should be enclosed in the appropriate
|
||||||
|
comment syntax for the file format. We also recommend that a
|
||||||
|
file or class name and description of purpose be included on the
|
||||||
|
same "printed page" as the copyright notice for easier
|
||||||
|
identification within third-party archives.
|
||||||
|
|
||||||
|
Copyright [yyyy] [name of copyright owner]
|
||||||
|
|
||||||
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
you may not use this file except in compliance with the License.
|
||||||
|
You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing, software
|
||||||
|
distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
See the License for the specific language governing permissions and
|
||||||
|
limitations under the License.
|
||||||
23
syn-serde/LICENSE-MIT
Normal file
23
syn-serde/LICENSE-MIT
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
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.
|
||||||
130
syn-serde/README.md
Normal file
130
syn-serde/README.md
Normal file
|
|
@ -0,0 +1,130 @@
|
||||||
|
# syn-serde
|
||||||
|
|
||||||
|
[![crates-badge]][crates-url]
|
||||||
|
[![docs-badge]][docs-url]
|
||||||
|
[![license-badge]][license]
|
||||||
|
[![rustc-badge]][rustc-url]
|
||||||
|
|
||||||
|
[crates-badge]: https://img.shields.io/crates/v/syn-serde.svg
|
||||||
|
[crates-url]: https://crates.io/crates/syn-serde
|
||||||
|
[docs-badge]: https://docs.rs/syn-serde/badge.svg
|
||||||
|
[docs-url]: https://docs.rs/syn-serde
|
||||||
|
[license-badge]: https://img.shields.io/crates/l/syn-serde.svg
|
||||||
|
[license]: #license
|
||||||
|
[rustc-badge]: https://img.shields.io/badge/rustc-1.31+-lightgray.svg
|
||||||
|
[rustc-url]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
|
||||||
|
|
||||||
|
Library to serialize and deserialize [Syn] syntax trees.
|
||||||
|
|
||||||
|
[**Documentation**][docs-url]
|
||||||
|
|
||||||
|
## Usage
|
||||||
|
|
||||||
|
Add this to your `Cargo.toml`:
|
||||||
|
|
||||||
|
```toml
|
||||||
|
[dependencies]
|
||||||
|
syn-serde = "0.2"
|
||||||
|
```
|
||||||
|
|
||||||
|
The current syn-serde requires Rust 1.31 or later.
|
||||||
|
|
||||||
|
## Examples
|
||||||
|
|
||||||
|
```toml
|
||||||
|
[dependencies]
|
||||||
|
syn-serde = { version = "0.2", features = ["json"] }
|
||||||
|
syn = { version = "1", features = ["full"] }
|
||||||
|
```
|
||||||
|
|
||||||
|
```rust
|
||||||
|
use syn_serde::json;
|
||||||
|
|
||||||
|
let syn_file: syn::File = syn::parse_quote! {
|
||||||
|
fn main() {
|
||||||
|
println!("Hello, world!");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
println!("{}", json::to_string_pretty(&syn_file));
|
||||||
|
```
|
||||||
|
|
||||||
|
This prints the following JSON:
|
||||||
|
|
||||||
|
```json
|
||||||
|
{
|
||||||
|
"items": [
|
||||||
|
{
|
||||||
|
"fn": {
|
||||||
|
"ident": "main",
|
||||||
|
"inputs": [],
|
||||||
|
"output": null,
|
||||||
|
"stmts": [
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"macro": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "println"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"delimiter": "paren",
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"lit": "\"Hello, world!\""
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### Rust source file -> JSON representation of the syntax tree
|
||||||
|
|
||||||
|
The [`rust2json`] example parse a Rust source file into a `syn_serde::File`
|
||||||
|
and print out a JSON representation of the syntax tree.
|
||||||
|
|
||||||
|
[`rust2json`]: examples/rust2json
|
||||||
|
|
||||||
|
### JSON file -> Rust syntax tree
|
||||||
|
|
||||||
|
The [`json2rust`] example parse a JSON file into a `syn_serde::File` and
|
||||||
|
print out a Rust syntax tree.
|
||||||
|
|
||||||
|
[`json2rust`]: examples/json2rust
|
||||||
|
|
||||||
|
## Optional features
|
||||||
|
|
||||||
|
* **`json`** — Provides functions for JSON <-> Rust serializing and
|
||||||
|
deserializing.
|
||||||
|
|
||||||
|
## Relationship to Syn
|
||||||
|
|
||||||
|
syn-serde is a fork of [Syn], and syn-serde provides a set of data structures
|
||||||
|
similar but not identical to [Syn]. All data structures provided by syn-serde
|
||||||
|
can be converted to the data structures of [Syn] and [proc-macro2].
|
||||||
|
|
||||||
|
The data structures of syn-serde 0.2 is compatible with the data structures of [Syn] 1.0.
|
||||||
|
|
||||||
|
[Syn]: https://github.com/dtolnay/syn
|
||||||
|
[proc-macro2]: https://github.com/alexcrichton/proc-macro2
|
||||||
|
|
||||||
|
## 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 the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
|
||||||
29
syn-serde/ci/install-component.sh
Normal file
29
syn-serde/ci/install-component.sh
Normal file
|
|
@ -0,0 +1,29 @@
|
||||||
|
#!/bin/bash
|
||||||
|
|
||||||
|
set -euo pipefail
|
||||||
|
|
||||||
|
component="${1}"
|
||||||
|
|
||||||
|
if ! rustup component add "${component}" 2>/dev/null; then
|
||||||
|
# If the component is unavailable on the latest nightly,
|
||||||
|
# use the latest toolchain with the component available.
|
||||||
|
# Refs: https://github.com/rust-lang/rustup-components-history#the-web-part
|
||||||
|
target=$(curl -sSf "https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/${component}")
|
||||||
|
echo "'${component}' is unavailable on the default toolchain, use the toolchain 'nightly-${target}' instead"
|
||||||
|
|
||||||
|
rustup update "nightly-${target}" --no-self-update
|
||||||
|
rustup default "nightly-${target}"
|
||||||
|
|
||||||
|
echo "Query rust and cargo versions:"
|
||||||
|
rustup -V
|
||||||
|
rustc -V
|
||||||
|
cargo -V
|
||||||
|
|
||||||
|
rustup component add "${component}"
|
||||||
|
fi
|
||||||
|
|
||||||
|
echo "Query component versions:"
|
||||||
|
case "${component}" in
|
||||||
|
clippy | miri) cargo "${component}" -V ;;
|
||||||
|
rustfmt) "${component}" -V ;;
|
||||||
|
esac
|
||||||
20
syn-serde/ci/install-rust.sh
Normal file
20
syn-serde/ci/install-rust.sh
Normal file
|
|
@ -0,0 +1,20 @@
|
||||||
|
#!/bin/bash
|
||||||
|
|
||||||
|
set -euo pipefail
|
||||||
|
|
||||||
|
toolchain="${1:-nightly}"
|
||||||
|
|
||||||
|
if rustup -V 2>/dev/null; then
|
||||||
|
rustup set profile minimal
|
||||||
|
rustup update "${toolchain}" --no-self-update
|
||||||
|
rustup default "${toolchain}"
|
||||||
|
else
|
||||||
|
curl -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain "${toolchain}"
|
||||||
|
export PATH=${PATH}:${HOME}/.cargo/bin
|
||||||
|
echo "##[add-path]${HOME}/.cargo/bin"
|
||||||
|
fi
|
||||||
|
|
||||||
|
echo "Query rust and cargo versions:"
|
||||||
|
rustup -V
|
||||||
|
rustc -V
|
||||||
|
cargo -V
|
||||||
17
syn-serde/codegen/Cargo.toml
Normal file
17
syn-serde/codegen/Cargo.toml
Normal file
|
|
@ -0,0 +1,17 @@
|
||||||
|
[package]
|
||||||
|
name = "syn-serde-internal-codegen"
|
||||||
|
version = "0.0.0"
|
||||||
|
authors = ["David Tolnay <dtolnay@gmail.com>", "Nika Layzell <nika@thelayzells.com>", "Taiki Endo <te316e89@gmail.com>"]
|
||||||
|
edition = "2018"
|
||||||
|
publish = false # this is an internal crate which should never be published
|
||||||
|
|
||||||
|
[workspace]
|
||||||
|
# Prefer that `cargo clean` in syn-serde's directory does not require a rebuild of
|
||||||
|
# rustfmt in the codegen directory.
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
proc-macro2 = "1.0"
|
||||||
|
quote = "1.0"
|
||||||
|
rustfmt = { package = "rustfmt-nightly", git = "https://github.com/rust-lang-nursery/rustfmt" }
|
||||||
|
serde_json = "1.0"
|
||||||
|
syn-codegen = { git = "https://github.com/dtolnay/syn" }
|
||||||
12
syn-serde/codegen/README.md
Normal file
12
syn-serde/codegen/README.md
Normal file
|
|
@ -0,0 +1,12 @@
|
||||||
|
# syn_serde_codegen
|
||||||
|
|
||||||
|
This is an internal (not published on crates.io) crate which is used to generate
|
||||||
|
the files in the `gen/` directory of `syn-serde`. It is used to ensure that the
|
||||||
|
implementations for `Syn` remain in sync with the
|
||||||
|
actual AST.
|
||||||
|
|
||||||
|
To run this program, run `cargo run` in this directory, and the `gen/` folder
|
||||||
|
will be re-generated.
|
||||||
|
|
||||||
|
This program is slow, and is therefore not run when building `syn-serde` as part of
|
||||||
|
the build script to save on compile time.
|
||||||
40
syn-serde/codegen/src/file.rs
Normal file
40
syn-serde/codegen/src/file.rs
Normal file
|
|
@ -0,0 +1,40 @@
|
||||||
|
use crate::Result;
|
||||||
|
use proc_macro2::TokenStream;
|
||||||
|
use std::{fmt, fs, io::Write, path::Path};
|
||||||
|
|
||||||
|
pub(crate) fn write<P: AsRef<Path>>(path: P, content: TokenStream) -> Result<()> {
|
||||||
|
let mut formatted = Vec::new();
|
||||||
|
writeln!(
|
||||||
|
formatted,
|
||||||
|
"// This file is @generated by syn-serde-internal-codegen.\n\
|
||||||
|
// It is not intended for manual editing.\n"
|
||||||
|
)?;
|
||||||
|
|
||||||
|
let mut config = rustfmt::Config::default();
|
||||||
|
config.set().emit_mode(rustfmt::EmitMode::Stdout);
|
||||||
|
config.set().verbose(rustfmt::Verbosity::Quiet);
|
||||||
|
config.set().format_macro_matchers(true);
|
||||||
|
config.set().normalize_doc_attributes(true);
|
||||||
|
|
||||||
|
let mut session = rustfmt::Session::new(config, Some(&mut formatted));
|
||||||
|
session.format(rustfmt::Input::Text(content.to_string())).map_err(RustfmtError)?;
|
||||||
|
drop(session);
|
||||||
|
|
||||||
|
if path.as_ref().is_file() && fs::read(&path)? == formatted {
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::write(path, formatted)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct RustfmtError(rustfmt::ErrorKind);
|
||||||
|
|
||||||
|
impl fmt::Display for RustfmtError {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
self.0.fmt(f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl std::error::Error for RustfmtError {}
|
||||||
20
syn-serde/codegen/src/gen.rs
Normal file
20
syn-serde/codegen/src/gen.rs
Normal file
|
|
@ -0,0 +1,20 @@
|
||||||
|
use proc_macro2::TokenStream;
|
||||||
|
use syn_codegen::{Definitions, Node};
|
||||||
|
|
||||||
|
pub(crate) fn traverse(
|
||||||
|
defs: &Definitions,
|
||||||
|
node: fn(&mut TokenStream, &Node, &Definitions),
|
||||||
|
) -> TokenStream {
|
||||||
|
let mut types = defs.types.clone();
|
||||||
|
types.sort_by(|a, b| a.ident.cmp(&b.ident));
|
||||||
|
|
||||||
|
let mut traits = TokenStream::new();
|
||||||
|
for s in types {
|
||||||
|
if s.ident == "Reserved" {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
node(&mut traits, &s, defs);
|
||||||
|
}
|
||||||
|
|
||||||
|
traits
|
||||||
|
}
|
||||||
32
syn-serde/codegen/src/main.rs
Normal file
32
syn-serde/codegen/src/main.rs
Normal file
|
|
@ -0,0 +1,32 @@
|
||||||
|
// Based on https://github.com/dtolnay/syn/tree/1.0.5/codegen.
|
||||||
|
//
|
||||||
|
// This crate generates the Syn trait in syn-serde programmatically from
|
||||||
|
// the syntax tree description.
|
||||||
|
|
||||||
|
#![recursion_limit = "128"]
|
||||||
|
#![warn(rust_2018_idioms, unreachable_pub)]
|
||||||
|
|
||||||
|
const SYN_JSON: &str = "../syn.json";
|
||||||
|
|
||||||
|
mod file;
|
||||||
|
mod gen;
|
||||||
|
mod serde;
|
||||||
|
|
||||||
|
use std::fs;
|
||||||
|
|
||||||
|
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
if let Err(e) = try_main() {
|
||||||
|
eprintln!("error: {}", e);
|
||||||
|
std::process::exit(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_main() -> Result<()> {
|
||||||
|
let defs = fs::read_to_string(SYN_JSON)?;
|
||||||
|
let defs = serde_json::from_str(&defs)?;
|
||||||
|
|
||||||
|
serde::generate(&defs)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
293
syn-serde/codegen/src/serde.rs
Normal file
293
syn-serde/codegen/src/serde.rs
Normal file
|
|
@ -0,0 +1,293 @@
|
||||||
|
use crate::{file, gen, Result};
|
||||||
|
use proc_macro2::TokenStream;
|
||||||
|
use quote::{format_ident, quote};
|
||||||
|
use syn_codegen::{Data, Definitions, Node, Type};
|
||||||
|
|
||||||
|
const SERDE_SRC: &str = "../src/gen/mod.rs";
|
||||||
|
|
||||||
|
const IGNORED_TYPES: &[&str] = &[
|
||||||
|
/* we don't have them */
|
||||||
|
"DeriveInput",
|
||||||
|
"Data",
|
||||||
|
"DataStruct",
|
||||||
|
"DataEnum",
|
||||||
|
"DataUnion",
|
||||||
|
/* private */
|
||||||
|
"LitByte",
|
||||||
|
"LitByteStr",
|
||||||
|
"LitChar",
|
||||||
|
"LitFloat",
|
||||||
|
"LitInt",
|
||||||
|
"LitStr",
|
||||||
|
/* cannot be implemented by codegen */
|
||||||
|
"Type",
|
||||||
|
"UseTree",
|
||||||
|
"Visibility",
|
||||||
|
"Receiver",
|
||||||
|
/* optimize */
|
||||||
|
"Generics",
|
||||||
|
"ExprMatch",
|
||||||
|
"Arm",
|
||||||
|
"TraitItemMethod",
|
||||||
|
"ItemStruct",
|
||||||
|
"ReturnType",
|
||||||
|
];
|
||||||
|
const EMPTY_STRUCTS: &[&str] = &["TypeInfer", "TypeNever", "UseGlob", "VisCrate", "VisPublic"];
|
||||||
|
|
||||||
|
#[allow(clippy::cognitive_complexity)]
|
||||||
|
fn visit(ty: &Type, name: &TokenStream) -> (Option<TokenStream>, TokenStream) {
|
||||||
|
match ty {
|
||||||
|
Type::Box(_) | Type::Vec(_) | Type::Punctuated(_) => {
|
||||||
|
let from = Some(quote!(#name.map_into()));
|
||||||
|
let into = quote!(#name.map_into());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Option(t) => match &**t {
|
||||||
|
Type::Token(_) | Type::Group(_) => {
|
||||||
|
let from = Some(quote!(#name.is_some()));
|
||||||
|
let into = quote!(default_or_none(#name));
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Tuple(t) => {
|
||||||
|
let mut from_expr = Vec::new();
|
||||||
|
let mut from_pat = Vec::new();
|
||||||
|
let mut into_expr = Vec::new();
|
||||||
|
let mut into_pat = Vec::new();
|
||||||
|
|
||||||
|
for (i, t) in t.iter().enumerate() {
|
||||||
|
let id = format_ident!("_{}", i);
|
||||||
|
let (from, into) = visit(t, "e!((*#id)));
|
||||||
|
|
||||||
|
from_pat.push(id.clone());
|
||||||
|
into_expr.push(into);
|
||||||
|
if from.is_some() {
|
||||||
|
into_pat.push(id);
|
||||||
|
from_expr.push(from);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert_eq!(from_pat.len(), into_expr.len());
|
||||||
|
assert_eq!(into_pat.len(), from_expr.len());
|
||||||
|
assert_ne!(into_pat.len(), 0);
|
||||||
|
|
||||||
|
if into_pat.len() == 1 {
|
||||||
|
let from = Some(quote!(#name.ref_map(|(#(#from_pat),*)| #(#from_expr),*)));
|
||||||
|
let into = quote!(#name.ref_map(|#(#into_pat),*| (#(#into_expr),*)));
|
||||||
|
(from, into)
|
||||||
|
} else {
|
||||||
|
let from = Some(quote!(#name.ref_map(|(#(#from_pat),*)| (#(#from_expr),*))));
|
||||||
|
let into = quote!(#name.ref_map(|(#(#into_pat),*)| (#(#into_expr),*)));
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Type::Box(_) | Type::Vec(_) | Type::Punctuated(_) => {
|
||||||
|
let from = Some(quote!(#name.ref_map(MapInto::map_into)));
|
||||||
|
let into = quote!(#name.ref_map(MapInto::map_into));
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Std(t) if t == "String" => {
|
||||||
|
// `From<&String> for String` requires Rust 1.36 or later.
|
||||||
|
// Refs: https://github.com/rust-lang/rust/pull/59825
|
||||||
|
let from = Some(quote!(#name.ref_map(ToString::to_string)));
|
||||||
|
let into = quote!(#name.ref_map(ToString::to_string));
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
let from = Some(quote!(#name.map_into()));
|
||||||
|
let into = quote!(#name.map_into());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
Type::Token(_) | Type::Group(_) => {
|
||||||
|
let from = None;
|
||||||
|
let into = quote!(default());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Syn(t) if t == "Reserved" => {
|
||||||
|
let from = None;
|
||||||
|
let into = quote!(default());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Ext(t) if t == "Span" => {
|
||||||
|
let from = None;
|
||||||
|
let into = quote!(proc_macro2::Span::call_site());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Syn(_) | Type::Ext(_) => {
|
||||||
|
let from = Some(quote!(#name.ref_into()));
|
||||||
|
let into = quote!(#name.ref_into());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Std(_) => {
|
||||||
|
let from = Some(quote!(#name.into()));
|
||||||
|
let into = quote!(#name.into());
|
||||||
|
(from, into)
|
||||||
|
}
|
||||||
|
Type::Tuple(t) => unreachable!("Type::Tuple: {:?}", t),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(clippy::cognitive_complexity)]
|
||||||
|
fn node(traits: &mut TokenStream, node: &Node, _defs: &Definitions) {
|
||||||
|
if IGNORED_TYPES.contains(&&*node.ident) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let ty = format_ident!("{}", &node.ident);
|
||||||
|
|
||||||
|
let mut from_impl = TokenStream::new();
|
||||||
|
let mut into_impl = TokenStream::new();
|
||||||
|
|
||||||
|
match &node.data {
|
||||||
|
Data::Enum(variants) => {
|
||||||
|
let mut from_variants = TokenStream::new();
|
||||||
|
let mut into_variants = TokenStream::new();
|
||||||
|
|
||||||
|
for (variant, fields) in variants {
|
||||||
|
let variant_ident = format_ident!("{}", variant);
|
||||||
|
|
||||||
|
if fields.is_empty() {
|
||||||
|
from_variants.extend(quote! {
|
||||||
|
syn::#ty::#variant_ident => {
|
||||||
|
#ty::#variant_ident
|
||||||
|
}
|
||||||
|
});
|
||||||
|
into_variants.extend(quote! {
|
||||||
|
#ty::#variant_ident => {
|
||||||
|
syn::#ty::#variant_ident
|
||||||
|
}
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
let mut from_expr = Vec::new();
|
||||||
|
let mut from_pat = Vec::new();
|
||||||
|
let mut into_expr = Vec::new();
|
||||||
|
let mut into_pat = Vec::new();
|
||||||
|
|
||||||
|
for (i, t) in fields.iter().enumerate() {
|
||||||
|
let id = format_ident!("_{}", i);
|
||||||
|
let (from, into) = visit(t, "e!((*#id)));
|
||||||
|
|
||||||
|
from_pat.push(id.clone());
|
||||||
|
into_expr.push(into);
|
||||||
|
if from.is_some() {
|
||||||
|
into_pat.push(id);
|
||||||
|
from_expr.push(from);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if from_expr.is_empty() {
|
||||||
|
from_variants.extend(quote! {
|
||||||
|
syn::#ty::#variant_ident(..) => {
|
||||||
|
#ty::#variant_ident
|
||||||
|
}
|
||||||
|
});
|
||||||
|
into_variants.extend(quote! {
|
||||||
|
#ty::#variant_ident => {
|
||||||
|
syn::#ty::#variant_ident(#(#into_expr),*)
|
||||||
|
}
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
from_variants.extend(quote! {
|
||||||
|
syn::#ty::#variant_ident(#(#from_pat),*) => {
|
||||||
|
#ty::#variant_ident(#(#from_expr),*)
|
||||||
|
}
|
||||||
|
});
|
||||||
|
into_variants.extend(quote! {
|
||||||
|
#ty::#variant_ident(#(#into_pat),*) => {
|
||||||
|
syn::#ty::#variant_ident(#(#into_expr),*)
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let nonexhaustive =
|
||||||
|
if node.exhaustive { None } else { Some(quote!(_ => unreachable!())) };
|
||||||
|
|
||||||
|
from_impl.extend(quote! {
|
||||||
|
match node {
|
||||||
|
#from_variants
|
||||||
|
#nonexhaustive
|
||||||
|
}
|
||||||
|
});
|
||||||
|
into_impl.extend(quote! {
|
||||||
|
match node {
|
||||||
|
#into_variants
|
||||||
|
#nonexhaustive
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Data::Struct(fields) => {
|
||||||
|
let mut from_fields = TokenStream::new();
|
||||||
|
let mut into_fields = TokenStream::new();
|
||||||
|
|
||||||
|
for (field, ty) in fields {
|
||||||
|
let id = format_ident!("{}", field);
|
||||||
|
let ref_toks = quote!(node.#id);
|
||||||
|
|
||||||
|
let (from, into) = visit(&ty, &ref_toks);
|
||||||
|
|
||||||
|
if from.is_some() {
|
||||||
|
from_fields.extend(quote! {
|
||||||
|
#id: #from,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
into_fields.extend(quote! {
|
||||||
|
#id: #into,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
assert!(!fields.is_empty(), "fields.is_empty: {}", ty);
|
||||||
|
if !from_fields.is_empty() {
|
||||||
|
from_impl.extend(quote! {
|
||||||
|
#ty {
|
||||||
|
#from_fields
|
||||||
|
}
|
||||||
|
});
|
||||||
|
into_impl.extend(quote! {
|
||||||
|
syn::#ty {
|
||||||
|
#into_fields
|
||||||
|
}
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
assert!(EMPTY_STRUCTS.contains(&&*node.ident), "from_fields.is_empty(): {}", ty);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Data::Private => unreachable!("Data::Private: {}", ty),
|
||||||
|
}
|
||||||
|
|
||||||
|
traits.extend(quote! {
|
||||||
|
syn_trait_impl!(syn::#ty);
|
||||||
|
impl From<&syn::#ty> for #ty {
|
||||||
|
fn from(node: &syn::#ty) -> Self {
|
||||||
|
#from_impl
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&#ty> for syn::#ty {
|
||||||
|
fn from(node: &#ty) -> Self {
|
||||||
|
#into_impl
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn generate(defs: &Definitions) -> Result<()> {
|
||||||
|
let traits = gen::traverse(defs, node);
|
||||||
|
file::write(
|
||||||
|
SERDE_SRC,
|
||||||
|
quote! {
|
||||||
|
// Unreachable code is generated sometimes without the full feature.
|
||||||
|
#![allow(unreachable_code, unused_variables, unused_parens)]
|
||||||
|
#![allow(
|
||||||
|
clippy::double_parens,
|
||||||
|
clippy::identity_conversion,
|
||||||
|
clippy::just_underscores_and_digits,
|
||||||
|
)]
|
||||||
|
|
||||||
|
use crate::*;
|
||||||
|
|
||||||
|
#traits
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
9
syn-serde/examples/README.md
Normal file
9
syn-serde/examples/README.md
Normal file
|
|
@ -0,0 +1,9 @@
|
||||||
|
### [`rust2json`](rust2json)
|
||||||
|
|
||||||
|
**Rust -> JSON**.
|
||||||
|
Little utility to parse a Rust source file into a `syn_serde::File` and print out a JSON representation of the syntax tree.
|
||||||
|
|
||||||
|
### [`json2rust`](json2rust)
|
||||||
|
|
||||||
|
**JSON -> Rust**.
|
||||||
|
Little utility to parse a JSON file into a `syn_serde::File` and print out a Rust syntax tree.
|
||||||
12
syn-serde/examples/json2rust/Cargo.toml
Normal file
12
syn-serde/examples/json2rust/Cargo.toml
Normal file
|
|
@ -0,0 +1,12 @@
|
||||||
|
[package]
|
||||||
|
name = "json2rust"
|
||||||
|
version = "0.0.0"
|
||||||
|
authors = ["Taiki Endo <te316e89@gmail.com>"]
|
||||||
|
edition = "2018"
|
||||||
|
publish = false
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
quote = "1.0"
|
||||||
|
syn-serde = { path = "../..", features = ["json"] }
|
||||||
|
syn = { version = "1.0", features = ["full"] }
|
||||||
|
tempfile = "3.1"
|
||||||
7
syn-serde/examples/json2rust/README.md
Normal file
7
syn-serde/examples/json2rust/README.md
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
Parse a JSON file into a `syn_serde::File` and print out a Rust syntax tree.
|
||||||
|
|
||||||
|
```text
|
||||||
|
cargo run -- json2rust_main.json
|
||||||
|
```
|
||||||
|
|
||||||
|
The output is the same as which deleted blank line and comment from [src/main.rs](src/main.rs).
|
||||||
1147
syn-serde/examples/json2rust/json2rust_main.json
Normal file
1147
syn-serde/examples/json2rust/json2rust_main.json
Normal file
File diff suppressed because it is too large
Load diff
54
syn-serde/examples/json2rust/src/main.rs
Normal file
54
syn-serde/examples/json2rust/src/main.rs
Normal file
|
|
@ -0,0 +1,54 @@
|
||||||
|
#![warn(rust_2018_idioms)]
|
||||||
|
|
||||||
|
use quote::ToTokens;
|
||||||
|
use std::{
|
||||||
|
env, fs,
|
||||||
|
io::{self, BufWriter, Write},
|
||||||
|
path::PathBuf,
|
||||||
|
process::{Command, Stdio},
|
||||||
|
};
|
||||||
|
use syn_serde::json;
|
||||||
|
use tempfile::Builder;
|
||||||
|
|
||||||
|
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
if let Err(e) = try_main() {
|
||||||
|
eprintln!("{}", e);
|
||||||
|
std::process::exit(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_main() -> Result<()> {
|
||||||
|
let mut args = env::args_os();
|
||||||
|
let _ = args.next(); // executable name
|
||||||
|
|
||||||
|
let filepath = match (args.next(), args.next()) {
|
||||||
|
(Some(arg1), None) => PathBuf::from(arg1),
|
||||||
|
_ => {
|
||||||
|
println!("Usage: rust2json path/to/filename.rs");
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let json = fs::read_to_string(&filepath)?;
|
||||||
|
let syntax: syn::File = json::from_str(&json)?;
|
||||||
|
|
||||||
|
let outdir = Builder::new().prefix("json2rust").tempdir()?;
|
||||||
|
let outfile_path = outdir.path().join("expanded");
|
||||||
|
fs::write(&outfile_path, syntax.into_token_stream().to_string())?;
|
||||||
|
|
||||||
|
// Run rustfmt
|
||||||
|
// https://github.com/dtolnay/cargo-expand/blob/0.4.9/src/main.rs#L181-L182
|
||||||
|
let rustfmt_config_path = outdir.path().join("rustfmt.toml");
|
||||||
|
fs::write(rustfmt_config_path, "normalize_doc_attributes = true\n")?;
|
||||||
|
|
||||||
|
// Ignore any errors.
|
||||||
|
let _status = Command::new("rustfmt").arg(&outfile_path).stderr(Stdio::null()).status();
|
||||||
|
|
||||||
|
let writer = io::stdout();
|
||||||
|
let mut writer = BufWriter::new(writer.lock());
|
||||||
|
writer.write_all(fs::read_to_string(&outfile_path)?.as_bytes())?;
|
||||||
|
writer.flush()?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
10
syn-serde/examples/rust2json/Cargo.toml
Normal file
10
syn-serde/examples/rust2json/Cargo.toml
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
[package]
|
||||||
|
name = "rust2json"
|
||||||
|
version = "0.0.0"
|
||||||
|
authors = ["Taiki Endo <te316e89@gmail.com>"]
|
||||||
|
edition = "2018"
|
||||||
|
publish = false
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
syn-serde = { path = "../..", features = ["json"] }
|
||||||
|
syn = { version = "1.0", features = ["full"] }
|
||||||
7
syn-serde/examples/rust2json/README.md
Normal file
7
syn-serde/examples/rust2json/README.md
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
Parse a Rust source file into a `syn_serde::File` and print out a JSON representation of the syntax tree.
|
||||||
|
|
||||||
|
```text
|
||||||
|
cargo run -- src/main.rs
|
||||||
|
```
|
||||||
|
|
||||||
|
The output is the same as [rust2json_main.json](rust2json_main.json).
|
||||||
782
syn-serde/examples/rust2json/rust2json_main.json
Normal file
782
syn-serde/examples/rust2json/rust2json_main.json
Normal file
|
|
@ -0,0 +1,782 @@
|
||||||
|
{
|
||||||
|
"attrs": [
|
||||||
|
{
|
||||||
|
"style": "inner",
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "warn"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"group": {
|
||||||
|
"delimiter": "parenthesis",
|
||||||
|
"stream": [
|
||||||
|
{
|
||||||
|
"ident": "rust_2018_idioms"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"items": [
|
||||||
|
{
|
||||||
|
"use": {
|
||||||
|
"tree": {
|
||||||
|
"path": {
|
||||||
|
"ident": "std",
|
||||||
|
"tree": {
|
||||||
|
"group": [
|
||||||
|
{
|
||||||
|
"ident": "env"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "fs"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"path": {
|
||||||
|
"ident": "io",
|
||||||
|
"tree": {
|
||||||
|
"group": [
|
||||||
|
{
|
||||||
|
"ident": "self"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "BufWriter"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "Write"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"path": {
|
||||||
|
"ident": "path",
|
||||||
|
"tree": {
|
||||||
|
"ident": "PathBuf"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"use": {
|
||||||
|
"tree": {
|
||||||
|
"path": {
|
||||||
|
"ident": "syn_serde",
|
||||||
|
"tree": {
|
||||||
|
"ident": "json"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"ident": "Result",
|
||||||
|
"generics": {
|
||||||
|
"params": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"ident": "T"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "std"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "result"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "Result",
|
||||||
|
"arguments": {
|
||||||
|
"angle_bracketed": {
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "T"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Box",
|
||||||
|
"arguments": {
|
||||||
|
"angle_bracketed": {
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"trait_object": {
|
||||||
|
"dyn": true,
|
||||||
|
"bounds": [
|
||||||
|
{
|
||||||
|
"trait": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "std"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "error"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "Error"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"fn": {
|
||||||
|
"ident": "main",
|
||||||
|
"inputs": [],
|
||||||
|
"output": null,
|
||||||
|
"stmts": [
|
||||||
|
{
|
||||||
|
"expr": {
|
||||||
|
"if": {
|
||||||
|
"cond": {
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"tuple_struct": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Err"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"pat": {
|
||||||
|
"elems": [
|
||||||
|
{
|
||||||
|
"ident": {
|
||||||
|
"ident": "e"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"expr": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "try_main"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"then_branch": [
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"macro": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "eprintln"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"delimiter": "paren",
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"lit": "\"{}\""
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": ",",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "e"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "std"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "process"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "exit"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"lit": {
|
||||||
|
"int": "1"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"fn": {
|
||||||
|
"ident": "try_main",
|
||||||
|
"inputs": [],
|
||||||
|
"output": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Result",
|
||||||
|
"arguments": {
|
||||||
|
"angle_bracketed": {
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"tuple": {
|
||||||
|
"elems": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"stmts": [
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"ident": {
|
||||||
|
"mut": true,
|
||||||
|
"ident": "args"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "env"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "args_os"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"_": {}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"method_call": {
|
||||||
|
"receiver": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "args"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"method": "next",
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"ident": {
|
||||||
|
"ident": "filepath"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"match": {
|
||||||
|
"expr": {
|
||||||
|
"tuple": {
|
||||||
|
"elems": [
|
||||||
|
{
|
||||||
|
"method_call": {
|
||||||
|
"receiver": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "args"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"method": "next",
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"method_call": {
|
||||||
|
"receiver": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "args"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"method": "next",
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"arms": [
|
||||||
|
{
|
||||||
|
"pat": {
|
||||||
|
"tuple": {
|
||||||
|
"elems": [
|
||||||
|
{
|
||||||
|
"tuple_struct": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Some"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"pat": {
|
||||||
|
"elems": [
|
||||||
|
{
|
||||||
|
"ident": {
|
||||||
|
"ident": "arg"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": {
|
||||||
|
"ident": "None"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"body": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "PathBuf"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "from"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "arg"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"pat": {
|
||||||
|
"_": {}
|
||||||
|
},
|
||||||
|
"body": {
|
||||||
|
"block": {
|
||||||
|
"stmts": [
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"macro": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "println"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"delimiter": "paren",
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"lit": "\"Usage: rust2json path/to/filename.rs\""
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"return": {
|
||||||
|
"expr": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Ok"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"tuple": {
|
||||||
|
"elems": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"ident": {
|
||||||
|
"ident": "code"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"try": {
|
||||||
|
"expr": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "fs"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "read_to_string"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"reference": {
|
||||||
|
"expr": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "filepath"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"ident": {
|
||||||
|
"ident": "syntax"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"try": {
|
||||||
|
"expr": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "syn"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "parse_file"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"reference": {
|
||||||
|
"expr": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "code"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"ident": {
|
||||||
|
"ident": "writer"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "io"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "stdout"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"let": {
|
||||||
|
"pat": {
|
||||||
|
"ident": {
|
||||||
|
"mut": true,
|
||||||
|
"ident": "writer"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"init": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "BufWriter"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "new"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"method_call": {
|
||||||
|
"receiver": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "writer"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"method": "lock",
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"try": {
|
||||||
|
"expr": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "json"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "to_writer_pretty"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"reference": {
|
||||||
|
"mut": true,
|
||||||
|
"expr": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "writer"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"reference": {
|
||||||
|
"expr": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "syntax"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"semi": {
|
||||||
|
"try": {
|
||||||
|
"expr": {
|
||||||
|
"method_call": {
|
||||||
|
"receiver": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "writer"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"method": "flush",
|
||||||
|
"args": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"expr": {
|
||||||
|
"call": {
|
||||||
|
"func": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Ok"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"tuple": {
|
||||||
|
"elems": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
39
syn-serde/examples/rust2json/src/main.rs
Normal file
39
syn-serde/examples/rust2json/src/main.rs
Normal file
|
|
@ -0,0 +1,39 @@
|
||||||
|
#![warn(rust_2018_idioms)]
|
||||||
|
|
||||||
|
use std::{
|
||||||
|
env, fs,
|
||||||
|
io::{self, BufWriter, Write},
|
||||||
|
path::PathBuf,
|
||||||
|
};
|
||||||
|
use syn_serde::json;
|
||||||
|
|
||||||
|
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
if let Err(e) = try_main() {
|
||||||
|
eprintln!("{}", e);
|
||||||
|
std::process::exit(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_main() -> Result<()> {
|
||||||
|
let mut args = env::args_os();
|
||||||
|
let _ = args.next(); // executable name
|
||||||
|
|
||||||
|
let filepath = match (args.next(), args.next()) {
|
||||||
|
(Some(arg), None) => PathBuf::from(arg),
|
||||||
|
_ => {
|
||||||
|
println!("Usage: rust2json path/to/filename.rs");
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let code = fs::read_to_string(&filepath)?;
|
||||||
|
let syntax = syn::parse_file(&code)?;
|
||||||
|
|
||||||
|
let writer = io::stdout();
|
||||||
|
let mut writer = BufWriter::new(writer.lock());
|
||||||
|
json::to_writer_pretty(&mut writer, &syntax)?;
|
||||||
|
writer.flush()?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
115
syn-serde/src/attr.rs
Normal file
115
syn-serde/src/attr.rs
Normal file
|
|
@ -0,0 +1,115 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An attribute like `#[repr(transparent)]`.
|
||||||
|
///
|
||||||
|
/// # Syntax
|
||||||
|
///
|
||||||
|
/// Rust has six types of attributes.
|
||||||
|
///
|
||||||
|
/// - Outer attributes like `#[repr(transparent)]`. These appear outside or
|
||||||
|
/// in front of the item they describe.
|
||||||
|
/// - Inner attributes like `#![feature(proc_macro)]`. These appear inside
|
||||||
|
/// of the item they describe, usually a module.
|
||||||
|
/// - Outer doc comments like `/// # Example`.
|
||||||
|
/// - Inner doc comments like `//! Please file an issue`.
|
||||||
|
/// - Outer block comments `/** # Example */`.
|
||||||
|
/// - Inner block comments `/*! Please file an issue */`.
|
||||||
|
///
|
||||||
|
/// The `style` field of type `AttrStyle` distinguishes whether an attribute
|
||||||
|
/// is outer or inner. Doc comments and block comments are promoted to
|
||||||
|
/// attributes, as this is how they are processed by the compiler and by
|
||||||
|
/// `macro_rules!` macros.
|
||||||
|
///
|
||||||
|
/// The `path` field gives the possibly colon-delimited path against which
|
||||||
|
/// the attribute is resolved. It is equal to `"doc"` for desugared doc
|
||||||
|
/// comments. The `tokens` field contains the rest of the attribute body as
|
||||||
|
/// tokens.
|
||||||
|
///
|
||||||
|
/// ```text
|
||||||
|
/// #[derive(Copy)] #[crate::precondition x < 5]
|
||||||
|
/// ^^^^^^~~~~~~ ^^^^^^^^^^^^^^^^^^^ ~~~~~
|
||||||
|
/// path tokens path tokens
|
||||||
|
/// ```
|
||||||
|
pub struct Attribute {
|
||||||
|
pub(crate) style: AttrStyle,
|
||||||
|
pub(crate) path: Path,
|
||||||
|
#[serde(default, skip_serializing_if = "TokenStream::is_empty")]
|
||||||
|
pub(crate) tokens: TokenStream,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Distinguishes between attributes that decorate an item and attributes
|
||||||
|
/// that are contained within an item.
|
||||||
|
///
|
||||||
|
/// # Outer attributes
|
||||||
|
///
|
||||||
|
/// - `#[repr(transparent)]`
|
||||||
|
/// - `/// # Example`
|
||||||
|
/// - `/** Please file an issue */`
|
||||||
|
///
|
||||||
|
/// # Inner attributes
|
||||||
|
///
|
||||||
|
/// - `#![feature(proc_macro)]`
|
||||||
|
/// - `//! # Example`
|
||||||
|
/// - `/*! Please file an issue */`
|
||||||
|
pub enum AttrStyle {
|
||||||
|
Outer,
|
||||||
|
Inner,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Content of a compile-time structured attribute.
|
||||||
|
///
|
||||||
|
/// ## Path
|
||||||
|
///
|
||||||
|
/// A meta path is like the `test` in `#[test]`.
|
||||||
|
///
|
||||||
|
/// ## List
|
||||||
|
///
|
||||||
|
/// A meta list is like the `derive(Copy)` in `#[derive(Copy)]`.
|
||||||
|
///
|
||||||
|
/// ## NameValue
|
||||||
|
///
|
||||||
|
/// A name-value meta is like the `path = "..."` in `#[path =
|
||||||
|
/// "sys/windows.rs"]`.
|
||||||
|
pub enum Meta {
|
||||||
|
Path(Path),
|
||||||
|
|
||||||
|
/// A structured list within an attribute, like `derive(Copy, Clone)`.
|
||||||
|
List(MetaList),
|
||||||
|
|
||||||
|
/// A name-value pair within an attribute, like `feature = "nightly"`.
|
||||||
|
NameValue(MetaNameValue),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A structured list within an attribute, like `derive(Copy, Clone)`.
|
||||||
|
pub struct MetaList {
|
||||||
|
pub(crate) path: Path,
|
||||||
|
pub(crate) nested: Punctuated<NestedMeta>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A name-value pair within an attribute, like `feature = "nightly"`.
|
||||||
|
pub struct MetaNameValue {
|
||||||
|
pub(crate) path: Path,
|
||||||
|
pub(crate) lit: Lit,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Element of a compile-time attribute list.
|
||||||
|
pub enum NestedMeta {
|
||||||
|
/// A structured meta item, like the `Copy` in `#[derive(Copy)]` which
|
||||||
|
/// would be a nested `Meta::Word`.
|
||||||
|
Meta(Meta),
|
||||||
|
|
||||||
|
/// A Rust literal, like the `"new_name"` in `#[rename("new_name")]`.
|
||||||
|
Lit(Lit),
|
||||||
|
}
|
||||||
|
}
|
||||||
185
syn-serde/src/data.rs
Normal file
185
syn-serde/src/data.rs
Normal file
|
|
@ -0,0 +1,185 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An enum variant.
|
||||||
|
pub struct Variant {
|
||||||
|
/// Attributes tagged on the variant.
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
|
||||||
|
/// Name of the variant.
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
|
||||||
|
/// Content stored in the variant.
|
||||||
|
pub(crate) fields: Fields,
|
||||||
|
|
||||||
|
/// Explicit discriminant: `Variant = 1`
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) discriminant: Option<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Data stored within an enum variant or struct.
|
||||||
|
pub enum Fields {
|
||||||
|
/// Named fields of a struct or struct variant such as `Point { x: f64,
|
||||||
|
/// y: f64 }`.
|
||||||
|
Named(FieldsNamed),
|
||||||
|
|
||||||
|
/// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`.
|
||||||
|
Unnamed(FieldsUnnamed),
|
||||||
|
|
||||||
|
/// Unit struct or unit variant such as `None`.
|
||||||
|
Unit,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Named fields of a struct or struct variant such as `Point { x: f64,
|
||||||
|
/// y: f64 }`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct FieldsNamed {
|
||||||
|
pub(crate) named: Punctuated<Field>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct FieldsUnnamed {
|
||||||
|
pub(crate) unnamed: Punctuated<Field>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Fields {
|
||||||
|
pub(crate) fn is_named(&self) -> bool {
|
||||||
|
match self {
|
||||||
|
Fields::Named(_) => true,
|
||||||
|
Fields::Unnamed(_) | Fields::Unit => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// assertions
|
||||||
|
// `syn::perse*` functions will detect these, but there is a possibility to
|
||||||
|
// generate incorrect code by subsequent operations.
|
||||||
|
pub(crate) fn assert_struct_semi(fields: &Fields, semi_token: bool) {
|
||||||
|
match fields {
|
||||||
|
// struct foo {};
|
||||||
|
Fields::Named(_) => assert!(!semi_token, "unexpected token: `;`"),
|
||||||
|
// struct foo ()
|
||||||
|
Fields::Unnamed(_) => assert!(
|
||||||
|
semi_token,
|
||||||
|
"unexpected end of input, expected `where` or `;`"
|
||||||
|
),
|
||||||
|
// struct foo
|
||||||
|
Fields::Unit => assert!(
|
||||||
|
semi_token,
|
||||||
|
"unexpected end of input, expected one of: `where`, parentheses, curly braces, `;`"
|
||||||
|
),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A field of a struct or enum variant.
|
||||||
|
pub struct Field {
|
||||||
|
/// Attributes tagged on the field.
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
|
||||||
|
/// Visibility of the field.
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
|
||||||
|
/// Name of the field, if any.
|
||||||
|
///
|
||||||
|
/// Fields of tuple structs have no names.
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) ident: Option<Ident>,
|
||||||
|
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
|
||||||
|
/// Type of the field.
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// The visibility level of an item: inherited or `pub` or
|
||||||
|
/// `pub(restricted)`.
|
||||||
|
pub enum Visibility {
|
||||||
|
/// A public visibility level: `pub`.
|
||||||
|
#[serde(rename = "pub")]
|
||||||
|
Public,
|
||||||
|
|
||||||
|
/// A crate-level visibility: `crate`.
|
||||||
|
Crate,
|
||||||
|
|
||||||
|
/// A visibility level restricted to some path: `pub(self)` or
|
||||||
|
/// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
|
||||||
|
Restricted(VisRestricted),
|
||||||
|
|
||||||
|
/// An inherited visibility, which usually means private.
|
||||||
|
Inherited,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Visibility {
|
||||||
|
pub(crate) fn is_inherited(&self) -> bool {
|
||||||
|
match self {
|
||||||
|
Visibility::Inherited => true,
|
||||||
|
_ => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for Visibility {
|
||||||
|
fn default() -> Self {
|
||||||
|
Visibility::Inherited
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A visibility level restricted to some path: `pub(self)` or
|
||||||
|
/// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
|
||||||
|
pub struct VisRestricted {
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) in_token: bool,
|
||||||
|
pub(crate) path: Box<Path>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// Visibility
|
||||||
|
syn_trait_impl!(syn::Visibility);
|
||||||
|
impl From<&syn::Visibility> for Visibility {
|
||||||
|
fn from(other: &syn::Visibility) -> Self {
|
||||||
|
use super::Visibility::*;
|
||||||
|
use syn::Visibility;
|
||||||
|
match other {
|
||||||
|
Visibility::Public(_) => Public,
|
||||||
|
Visibility::Crate(_) => Crate,
|
||||||
|
Visibility::Restricted(x) => Restricted(x.ref_into()),
|
||||||
|
Visibility::Inherited => Inherited,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Visibility> for syn::Visibility {
|
||||||
|
fn from(other: &Visibility) -> Self {
|
||||||
|
use syn::Visibility::*;
|
||||||
|
match other {
|
||||||
|
Visibility::Public => Public(syn::VisPublic {
|
||||||
|
pub_token: default(),
|
||||||
|
}),
|
||||||
|
Visibility::Crate => Crate(syn::VisCrate {
|
||||||
|
crate_token: default(),
|
||||||
|
}),
|
||||||
|
Visibility::Restricted(x) => Restricted(x.into()),
|
||||||
|
Visibility::Inherited => Inherited,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
779
syn-serde/src/expr.rs
Normal file
779
syn-serde/src/expr.rs
Normal file
|
|
@ -0,0 +1,779 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A Rust expression.
|
||||||
|
pub enum Expr {
|
||||||
|
/// A slice literal expression: `[a, b, c, d]`.
|
||||||
|
Array(ExprArray),
|
||||||
|
|
||||||
|
/// An assignment expression: `a = compute()`.
|
||||||
|
Assign(ExprAssign),
|
||||||
|
|
||||||
|
/// A compound assignment expression: `counter += 1`.
|
||||||
|
AssignOp(ExprAssignOp),
|
||||||
|
|
||||||
|
/// An async block: `async { ... }`.
|
||||||
|
Async(ExprAsync),
|
||||||
|
|
||||||
|
/// An await expression: `fut.await`.
|
||||||
|
Await(ExprAwait),
|
||||||
|
|
||||||
|
/// A binary operation: `a + b`, `a * b`.
|
||||||
|
Binary(ExprBinary),
|
||||||
|
|
||||||
|
/// A blocked scope: `{ ... }`.
|
||||||
|
Block(ExprBlock),
|
||||||
|
|
||||||
|
/// A box expression: `box f`.
|
||||||
|
Box(ExprBox),
|
||||||
|
|
||||||
|
/// A `break`, with an optional label to break and an optional
|
||||||
|
/// expression.
|
||||||
|
Break(ExprBreak),
|
||||||
|
|
||||||
|
/// A function call expression: `invoke(a, b)`.
|
||||||
|
Call(ExprCall),
|
||||||
|
|
||||||
|
/// A cast expression: `foo as f64`.
|
||||||
|
Cast(ExprCast),
|
||||||
|
|
||||||
|
/// A closure expression: `|a, b| a + b`.
|
||||||
|
Closure(ExprClosure),
|
||||||
|
|
||||||
|
/// A `continue`, with an optional label.
|
||||||
|
Continue(ExprContinue),
|
||||||
|
|
||||||
|
/// Access of a named struct field (`obj.k`) or unnamed tuple struct
|
||||||
|
/// field (`obj.0`).
|
||||||
|
Field(ExprField),
|
||||||
|
|
||||||
|
/// A for loop: `for pat in expr { ... }`.
|
||||||
|
ForLoop(ExprForLoop),
|
||||||
|
|
||||||
|
/// An expression contained within invisible delimiters.
|
||||||
|
///
|
||||||
|
/// This variant is important for faithfully representing the precedence
|
||||||
|
/// of expressions and is related to `None`-delimited spans in a
|
||||||
|
/// `TokenStream`.
|
||||||
|
Group(ExprGroup),
|
||||||
|
|
||||||
|
/// An `if` expression with an optional `else` block: `if expr { ... }
|
||||||
|
/// else { ... }`.
|
||||||
|
///
|
||||||
|
/// The `else` branch expression may only be an `If` or `Block`
|
||||||
|
/// expression, not any of the other types of expression.
|
||||||
|
If(ExprIf),
|
||||||
|
|
||||||
|
/// A square bracketed indexing expression: `vector[2]`.
|
||||||
|
Index(ExprIndex),
|
||||||
|
|
||||||
|
/// A `let` guard: `let Some(x) = opt`.
|
||||||
|
Let(ExprLet),
|
||||||
|
|
||||||
|
/// A literal in place of an expression: `1`, `"foo"`.
|
||||||
|
Lit(ExprLit),
|
||||||
|
|
||||||
|
/// Conditionless loop: `loop { ... }`.
|
||||||
|
Loop(ExprLoop),
|
||||||
|
|
||||||
|
/// A macro invocation expression: `format!("{}", q)`.
|
||||||
|
Macro(ExprMacro),
|
||||||
|
|
||||||
|
/// A `match` expression: `match n { Some(n) => {}, None => {} }`.
|
||||||
|
Match(ExprMatch),
|
||||||
|
|
||||||
|
/// A method call expression: `x.foo::<T>(a, b)`.
|
||||||
|
MethodCall(ExprMethodCall),
|
||||||
|
|
||||||
|
/// A parenthesized expression: `(a + b)`.
|
||||||
|
Paren(ExprParen),
|
||||||
|
|
||||||
|
/// A path like `std::mem::replace` possibly containing generic
|
||||||
|
/// parameters and a qualified self-type.
|
||||||
|
///
|
||||||
|
/// A plain identifier like `x` is a path of length 1.
|
||||||
|
Path(ExprPath),
|
||||||
|
|
||||||
|
/// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`.
|
||||||
|
Range(ExprRange),
|
||||||
|
|
||||||
|
/// A referencing operation: `&a` or `&mut a`.
|
||||||
|
Reference(ExprReference),
|
||||||
|
|
||||||
|
/// An array literal constructed from one repeated element: `[0u8; N]`.
|
||||||
|
Repeat(ExprRepeat),
|
||||||
|
|
||||||
|
/// A `return`, with an optional value to be returned.
|
||||||
|
Return(ExprReturn),
|
||||||
|
|
||||||
|
/// A struct literal expression: `Point { x: 1, y: 1 }`.
|
||||||
|
///
|
||||||
|
/// The `rest` provides the value of the remaining fields as in `S { a:
|
||||||
|
/// 1, b: 1, ..rest }`.
|
||||||
|
Struct(ExprStruct),
|
||||||
|
|
||||||
|
/// A try-expression: `expr?`.
|
||||||
|
Try(ExprTry),
|
||||||
|
|
||||||
|
/// A try block: `try { ... }`.
|
||||||
|
TryBlock(ExprTryBlock),
|
||||||
|
|
||||||
|
/// A tuple expression: `(a, b, c, d)`.
|
||||||
|
Tuple(ExprTuple),
|
||||||
|
|
||||||
|
/// A type ascription expression: `foo: f64`.
|
||||||
|
Type(ExprType),
|
||||||
|
|
||||||
|
/// A unary operation: `!x`, `*x`.
|
||||||
|
Unary(ExprUnary),
|
||||||
|
|
||||||
|
/// An unsafe block: `unsafe { ... }`.
|
||||||
|
Unsafe(ExprUnsafe),
|
||||||
|
|
||||||
|
/// Tokens in expression position not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
/// A while loop: `while expr { ... }`.
|
||||||
|
While(ExprWhile),
|
||||||
|
|
||||||
|
/// A yield expression: `yield expr`.
|
||||||
|
Yield(ExprYield),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A slice literal expression: `[a, b, c, d]`.
|
||||||
|
pub struct ExprArray {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) elems: Punctuated<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An assignment expression: `a = compute()`.
|
||||||
|
pub struct ExprAssign {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) left: Box<Expr>,
|
||||||
|
pub(crate) right: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A compound assignment expression: `counter += 1`.
|
||||||
|
pub struct ExprAssignOp {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) left: Box<Expr>,
|
||||||
|
pub(crate) op: BinOp,
|
||||||
|
pub(crate) right: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An async block: `async { ... }`.
|
||||||
|
pub struct ExprAsync {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "move")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) capture: bool,
|
||||||
|
#[serde(rename = "stmts")]
|
||||||
|
pub(crate) block: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An await expression: `fut.await`.
|
||||||
|
pub struct ExprAwait {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) base: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A binary operation: `a + b`, `a * b`.
|
||||||
|
pub struct ExprBinary {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) left: Box<Expr>,
|
||||||
|
pub(crate) op: BinOp,
|
||||||
|
pub(crate) right: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A blocked scope: `{ ... }`.
|
||||||
|
pub struct ExprBlock {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) label: Option<Label>,
|
||||||
|
#[serde(rename = "stmts")]
|
||||||
|
pub(crate) block: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A box expression: `box f`.
|
||||||
|
pub struct ExprBox {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A `break`, with an optional label to break and an optional
|
||||||
|
/// expression.
|
||||||
|
pub struct ExprBreak {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) label: Option<Lifetime>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) expr: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A function call expression: `invoke(a, b)`.
|
||||||
|
pub struct ExprCall {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) func: Box<Expr>,
|
||||||
|
pub(crate) args: Punctuated<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A cast expression: `foo as f64`.
|
||||||
|
pub struct ExprCast {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A closure expression: `|a, b| a + b`.
|
||||||
|
pub struct ExprClosure {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "async")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) asyncness: bool,
|
||||||
|
#[serde(rename = "static")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) movability: bool,
|
||||||
|
#[serde(rename = "move")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) capture: bool,
|
||||||
|
pub(crate) inputs: Punctuated<Pat>,
|
||||||
|
#[serde(default)]
|
||||||
|
pub(crate) output: ReturnType,
|
||||||
|
pub(crate) body: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A `continue`, with an optional label.
|
||||||
|
pub struct ExprContinue {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) label: Option<Lifetime>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Access of a named struct field (`obj.k`) or unnamed tuple struct
|
||||||
|
/// field (`obj.0`).
|
||||||
|
pub struct ExprField {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) base: Box<Expr>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) member: Member,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A for loop: `for pat in expr { ... }`.
|
||||||
|
pub struct ExprForLoop {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) label: Option<Label>,
|
||||||
|
pub(crate) pat: Pat,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
pub(crate) body: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An expression contained within invisible delimiters.
|
||||||
|
///
|
||||||
|
/// This variant is important for faithfully representing the precedence
|
||||||
|
/// of expressions and is related to `None`-delimited spans in a
|
||||||
|
/// `TokenStream`.
|
||||||
|
pub struct ExprGroup {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An `if` expression with an optional `else` block: `if expr { ... }
|
||||||
|
/// else { ... }`.
|
||||||
|
///
|
||||||
|
/// The `else` branch expression may only be an `If` or `Block`
|
||||||
|
/// expression, not any of the other types of expression.
|
||||||
|
pub struct ExprIf {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) cond: Box<Expr>,
|
||||||
|
pub(crate) then_branch: Block,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) else_branch: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A square bracketed indexing expression: `vector[2]`.
|
||||||
|
pub struct ExprIndex {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
pub(crate) index: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A `let` guard: `let Some(x) = opt`.
|
||||||
|
pub struct ExprLet {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) pat: Pat,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A literal in place of an expression: `1`, `"foo"`.
|
||||||
|
pub struct ExprLit {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) lit: Lit,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Conditionless loop: `loop { ... }`.
|
||||||
|
pub struct ExprLoop {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) label: Option<Label>,
|
||||||
|
pub(crate) body: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro invocation expression: `format!("{}", q)`.
|
||||||
|
pub struct ExprMacro {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A `match` expression: `match n { Some(n) => {}, None => {} }`.
|
||||||
|
pub struct ExprMatch {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
pub(crate) arms: Vec<Arm>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A method call expression: `x.foo::<T>(a, b)`.
|
||||||
|
pub struct ExprMethodCall {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) receiver: Box<Expr>,
|
||||||
|
pub(crate) method: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) turbofish: Option<MethodTurbofish>,
|
||||||
|
pub(crate) args: Punctuated<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A parenthesized expression: `(a + b)`.
|
||||||
|
pub struct ExprParen {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A path like `std::mem::replace` possibly containing generic
|
||||||
|
/// parameters and a qualified self-type.
|
||||||
|
///
|
||||||
|
/// A plain identifier like `x` is a path of length 1.
|
||||||
|
pub struct ExprPath {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) qself: Option<QSelf>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) path: Path,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`.
|
||||||
|
pub struct ExprRange {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) from: Option<Box<Expr>>,
|
||||||
|
pub(crate) limits: RangeLimits,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) to: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A referencing operation: `&a` or `&mut a`.
|
||||||
|
pub struct ExprReference {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
// #[serde(default, skip_serializing_if = "Reserved::is_default")]
|
||||||
|
// pub(crate) raw: Reserved,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An array literal constructed from one repeated element: `[0u8; N]`.
|
||||||
|
pub struct ExprRepeat {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
pub(crate) len: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A `return`, with an optional value to be returned.
|
||||||
|
pub struct ExprReturn {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) expr: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A struct literal expression: `Point { x: 1, y: 1 }`.
|
||||||
|
///
|
||||||
|
/// The `rest` provides the value of the remaining fields as in `S { a:
|
||||||
|
/// 1, b: 1, ..rest }`.
|
||||||
|
pub struct ExprStruct {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) path: Path,
|
||||||
|
pub(crate) fields: Punctuated<FieldValue>,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) dot2_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) rest: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A try-expression: `expr?`.
|
||||||
|
pub struct ExprTry {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A try block: `try { ... }`.
|
||||||
|
pub struct ExprTryBlock {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "stmts")]
|
||||||
|
pub(crate) block: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A tuple expression: `(a, b, c, d)`.
|
||||||
|
pub struct ExprTuple {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) elems: Punctuated<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A type ascription expression: `foo: f64`.
|
||||||
|
pub struct ExprType {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A unary operation: `!x`, `*x`.
|
||||||
|
pub struct ExprUnary {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) op: UnOp,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An unsafe block: `unsafe { ... }`.
|
||||||
|
pub struct ExprUnsafe {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "stmts")]
|
||||||
|
pub(crate) block: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A while loop: `while expr { ... }`.
|
||||||
|
pub struct ExprWhile {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) label: Option<Label>,
|
||||||
|
pub(crate) cond: Box<Expr>,
|
||||||
|
pub(crate) body: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A yield expression: `yield expr`.
|
||||||
|
pub struct ExprYield {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) expr: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A struct or tuple struct field accessed in a struct literal or field
|
||||||
|
/// expression.
|
||||||
|
pub enum Member {
|
||||||
|
/// A named field like `self.x`.
|
||||||
|
#[serde(rename = "ident")]
|
||||||
|
Named(Ident),
|
||||||
|
/// An unnamed field like `self.0`.
|
||||||
|
#[serde(rename = "index")]
|
||||||
|
Unnamed(Index),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// The index of an unnamed tuple struct field.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Index {
|
||||||
|
pub(crate) index: u32,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// The `::<>` explicit type parameters passed to a method call:
|
||||||
|
/// `parse::<u64>()`.
|
||||||
|
pub struct MethodTurbofish {
|
||||||
|
pub(crate) args: Punctuated<GenericMethodArgument>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// An individual generic argument to a method, like `T`.
|
||||||
|
pub enum GenericMethodArgument {
|
||||||
|
/// A type argument.
|
||||||
|
Type(Type),
|
||||||
|
/// 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! {
|
||||||
|
/// A field-value pair in a struct literal.
|
||||||
|
pub struct FieldValue {
|
||||||
|
/// Attributes tagged on the field.
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
|
||||||
|
/// Name or index of the field.
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) member: Member,
|
||||||
|
|
||||||
|
/// The colon in `Struct { x: x }`. If written in shorthand like
|
||||||
|
/// `Struct { x }`, there is no colon.
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
|
||||||
|
/// Value of the field.
|
||||||
|
pub(crate) expr: Expr,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A lifetime labeling a `for`, `while`, or `loop`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Label {
|
||||||
|
pub(crate) name: Lifetime,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// One arm of a `match` expression: `0...10 => { return true; }`.
|
||||||
|
pub struct Arm {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) pat: Pat,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) guard: Option<Box<Expr>>,
|
||||||
|
pub(crate) body: Box<Expr>,
|
||||||
|
// #[serde(default, skip_serializing_if = "not")]
|
||||||
|
// pub(crate) comma: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Limit types of a range, inclusive or exclusive.
|
||||||
|
pub enum RangeLimits {
|
||||||
|
/// Inclusive at the beginning, exclusive at the end.
|
||||||
|
#[serde(rename = "..")]
|
||||||
|
HalfOpen,
|
||||||
|
/// Inclusive at the beginning and end.
|
||||||
|
#[serde(rename = "..=")]
|
||||||
|
Closed,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn requires_terminator(expr: &Expr) -> bool {
|
||||||
|
// see https://github.com/rust-lang/rust/blob/eb8f2586e/src/libsyntax/parse/classify.rs#L17-L37
|
||||||
|
match expr {
|
||||||
|
Expr::Unsafe(..)
|
||||||
|
| Expr::Block(..)
|
||||||
|
| Expr::If(..)
|
||||||
|
| Expr::Match(..)
|
||||||
|
| Expr::While(..)
|
||||||
|
| Expr::Loop(..)
|
||||||
|
| Expr::ForLoop(..)
|
||||||
|
| Expr::Async(..)
|
||||||
|
| Expr::TryBlock(..) => false,
|
||||||
|
_ => true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// ExprMatch
|
||||||
|
syn_trait_impl!(syn::ExprMatch);
|
||||||
|
fn from_syn_arms(other: &[syn::Arm]) -> Vec<Arm> {
|
||||||
|
let last = other.len().saturating_sub(1);
|
||||||
|
other
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.map(|(i, other)| {
|
||||||
|
let body = other.body.map_into();
|
||||||
|
if i < last && requires_terminator(&*body) {
|
||||||
|
assert!(other.comma.is_some(), "expected `,`");
|
||||||
|
}
|
||||||
|
|
||||||
|
Arm {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
pat: other.pat.ref_into(),
|
||||||
|
guard: other.guard.ref_map(|(_, x)| x.map_into()),
|
||||||
|
body,
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
impl From<&syn::ExprMatch> for ExprMatch {
|
||||||
|
fn from(other: &syn::ExprMatch) -> Self {
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
expr: other.expr.map_into(),
|
||||||
|
arms: from_syn_arms(&other.arms),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&ExprMatch> for syn::ExprMatch {
|
||||||
|
fn from(other: &ExprMatch) -> Self {
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
match_token: default(),
|
||||||
|
expr: other.expr.map_into(),
|
||||||
|
brace_token: default(),
|
||||||
|
arms: other.arms.map_into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Arm
|
||||||
|
syn_trait_impl!(syn::Arm);
|
||||||
|
impl From<&syn::Arm> for Arm {
|
||||||
|
fn from(other: &syn::Arm) -> Self {
|
||||||
|
let body = other.body.map_into();
|
||||||
|
if requires_terminator(&*body) {
|
||||||
|
assert!(other.comma.is_some(), "expected `,`");
|
||||||
|
}
|
||||||
|
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
pat: other.pat.ref_into(),
|
||||||
|
guard: other.guard.ref_map(|(_, x)| x.map_into()),
|
||||||
|
body,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Arm> for syn::Arm {
|
||||||
|
fn from(other: &Arm) -> Self {
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
pat: other.pat.ref_into(),
|
||||||
|
guard: other.guard.ref_map(|x| (default(), x.map_into())),
|
||||||
|
fat_arrow_token: default(),
|
||||||
|
body: other.body.map_into(),
|
||||||
|
comma: default_or_none(requires_terminator(&*other.body)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
12
syn-serde/src/file.rs
Normal file
12
syn-serde/src/file.rs
Normal file
|
|
@ -0,0 +1,12 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A complete file of Rust source code.
|
||||||
|
pub struct File {
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) shebang: Option<String>,
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) items: Vec<Item>,
|
||||||
|
}
|
||||||
|
}
|
||||||
3398
syn-serde/src/gen/mod.rs
Normal file
3398
syn-serde/src/gen/mod.rs
Normal file
File diff suppressed because it is too large
Load diff
223
syn-serde/src/generics.rs
Normal file
223
syn-serde/src/generics.rs
Normal file
|
|
@ -0,0 +1,223 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Lifetimes and type parameters attached to a declaration of a function,
|
||||||
|
/// enum, trait, etc.
|
||||||
|
#[derive(Default)]
|
||||||
|
pub struct Generics {
|
||||||
|
// #[serde(default, skip_serializing_if = "not")]
|
||||||
|
// pub(crate) lt_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Punctuated::is_empty")]
|
||||||
|
pub(crate) params: Punctuated<GenericParam>,
|
||||||
|
// #[serde(default, skip_serializing_if = "not")]
|
||||||
|
// pub(crate) gt_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) where_clause: Option<WhereClause>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Generics {
|
||||||
|
pub(crate) fn is_none(&self) -> bool {
|
||||||
|
self.params.is_empty() && self.where_clause.is_none() // && !self.lt_token && !self.gt_token
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A generic type parameter, lifetime, or const generic: `T: Into<String>`,
|
||||||
|
/// `'a: 'b`, `const LEN: usize`.
|
||||||
|
pub enum GenericParam {
|
||||||
|
/// A generic type parameter: `T: Into<String>`.
|
||||||
|
Type(TypeParam),
|
||||||
|
|
||||||
|
/// A lifetime definition: `'a: 'b + 'c + 'd`.
|
||||||
|
Lifetime(LifetimeDef),
|
||||||
|
|
||||||
|
/// A const generic parameter: `const LENGTH: usize`.
|
||||||
|
Const(ConstParam),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A generic type parameter: `T: Into<String>`.
|
||||||
|
pub struct TypeParam {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Punctuated::is_empty")]
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) eq_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) default: Option<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A lifetime definition: `'a: 'b + 'c + 'd`.
|
||||||
|
pub struct LifetimeDef {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) lifetime: Lifetime,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Punctuated::is_empty")]
|
||||||
|
pub(crate) bounds: Punctuated<Lifetime>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A const generic parameter: `const LENGTH: usize`.
|
||||||
|
pub struct ConstParam {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) eq_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) default: Option<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A set of bound lifetimes: `for<'a, 'b, 'c>`.
|
||||||
|
#[derive(Default)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct BoundLifetimes {
|
||||||
|
pub(crate) lifetimes: Punctuated<LifetimeDef>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A trait or lifetime used as a bound on a type parameter.
|
||||||
|
pub enum TypeParamBound {
|
||||||
|
Trait(TraitBound),
|
||||||
|
Lifetime(Lifetime),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A trait used as a bound on a type parameter.
|
||||||
|
pub struct TraitBound {
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) paren_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "TraitBoundModifier::is_none")]
|
||||||
|
pub(crate) modifier: TraitBoundModifier,
|
||||||
|
/// The `for<'a>` in `for<'a> Foo<&'a T>`
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) lifetimes: Option<BoundLifetimes>,
|
||||||
|
/// The `Foo<&'a T>` in `for<'a> Foo<&'a T>`
|
||||||
|
pub(crate) path: Path,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A modifier on a trait bound, currently only used for the `?` in
|
||||||
|
/// `?Sized`.
|
||||||
|
pub enum TraitBoundModifier {
|
||||||
|
None,
|
||||||
|
Maybe,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TraitBoundModifier {
|
||||||
|
fn is_none(&self) -> bool {
|
||||||
|
match self {
|
||||||
|
TraitBoundModifier::None => true,
|
||||||
|
TraitBoundModifier::Maybe => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for TraitBoundModifier {
|
||||||
|
fn default() -> Self {
|
||||||
|
TraitBoundModifier::None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A `where` clause in a definition: `where T: Deserialize<'de>, D:
|
||||||
|
/// 'static`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct WhereClause {
|
||||||
|
pub(crate) predicates: Punctuated<WherePredicate>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A single predicate in a `where` clause: `T: Deserialize<'de>`.
|
||||||
|
pub enum WherePredicate {
|
||||||
|
/// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
|
||||||
|
Type(PredicateType),
|
||||||
|
|
||||||
|
/// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
|
||||||
|
Lifetime(PredicateLifetime),
|
||||||
|
|
||||||
|
/// An equality predicate in a `where` clause (unsupported).
|
||||||
|
Eq(PredicateEq),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
|
||||||
|
pub struct PredicateType {
|
||||||
|
/// Any lifetimes from a `for` binding
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) lifetimes: Option<BoundLifetimes>,
|
||||||
|
/// The type being bounded
|
||||||
|
pub(crate) bounded_ty: Type,
|
||||||
|
/// Trait and lifetime bounds (`Clone+Send+'static`)
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
|
||||||
|
pub struct PredicateLifetime {
|
||||||
|
pub(crate) lifetime: Lifetime,
|
||||||
|
pub(crate) bounds: Punctuated<Lifetime>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An equality predicate in a `where` clause (unsupported).
|
||||||
|
pub struct PredicateEq {
|
||||||
|
pub(crate) lhs_ty: Type,
|
||||||
|
pub(crate) rhs_ty: Type,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// Generics
|
||||||
|
syn_trait_impl!(syn::Generics);
|
||||||
|
impl From<&syn::Generics> for Generics {
|
||||||
|
fn from(other: &syn::Generics) -> Self {
|
||||||
|
// `ident ..>` or `ident <..`
|
||||||
|
assert_eq!(other.lt_token.is_some(), other.gt_token.is_some());
|
||||||
|
// `ident T`
|
||||||
|
assert!(
|
||||||
|
other.params.is_empty() || other.lt_token.is_some(),
|
||||||
|
"expected `<`"
|
||||||
|
);
|
||||||
|
|
||||||
|
Self {
|
||||||
|
params: other.params.map_into(),
|
||||||
|
where_clause: other.where_clause.map_into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Generics> for syn::Generics {
|
||||||
|
fn from(other: &Generics) -> Self {
|
||||||
|
Self {
|
||||||
|
lt_token: default_or_none(!other.params.is_empty()),
|
||||||
|
params: other.params.map_into(),
|
||||||
|
gt_token: default_or_none(!other.params.is_empty()),
|
||||||
|
where_clause: other.where_clause.map_into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
770
syn-serde/src/item.rs
Normal file
770
syn-serde/src/item.rs
Normal file
|
|
@ -0,0 +1,770 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Things that can appear directly inside of a module or scope.
|
||||||
|
pub enum Item {
|
||||||
|
/// A constant item: `const MAX: u16 = 65535`.
|
||||||
|
Const(ItemConst),
|
||||||
|
|
||||||
|
/// An enum definition: `enum Foo<A, B> { A(A), B(B) }`.
|
||||||
|
Enum(ItemEnum),
|
||||||
|
|
||||||
|
/// An `extern crate` item: `extern crate serde`.
|
||||||
|
ExternCrate(ItemExternCrate),
|
||||||
|
|
||||||
|
/// A free-standing function: `fn process(n: usize) -> Result<()> { ...
|
||||||
|
/// }`.
|
||||||
|
Fn(ItemFn),
|
||||||
|
|
||||||
|
/// A block of foreign items: `extern "C" { ... }`.
|
||||||
|
ForeignMod(ItemForeignMod),
|
||||||
|
|
||||||
|
/// An impl block providing trait or associated items: `impl<A> Trait
|
||||||
|
/// for Data<A> { ... }`.
|
||||||
|
Impl(ItemImpl),
|
||||||
|
|
||||||
|
/// A macro invocation, which includes `macro_rules!` definitions.
|
||||||
|
Macro(ItemMacro),
|
||||||
|
|
||||||
|
/// A 2.0-style declarative macro introduced by the `macro` keyword.
|
||||||
|
Macro2(ItemMacro2),
|
||||||
|
|
||||||
|
/// A module or module declaration: `mod m` or `mod m { ... }`.
|
||||||
|
Mod(ItemMod),
|
||||||
|
|
||||||
|
/// A static item: `static BIKE: Shed = Shed(42)`.
|
||||||
|
Static(ItemStatic),
|
||||||
|
|
||||||
|
/// A struct definition: `struct Foo<A> { x: A }`.
|
||||||
|
Struct(ItemStruct),
|
||||||
|
|
||||||
|
/// A trait definition: `pub trait Iterator { ... }`.
|
||||||
|
Trait(ItemTrait),
|
||||||
|
|
||||||
|
/// A trait alias: `pub trait SharableIterator = Iterator + Sync`.
|
||||||
|
TraitAlias(ItemTraitAlias),
|
||||||
|
|
||||||
|
/// A type alias: `type Result<T> = std::result::Result<T, MyError>`.
|
||||||
|
Type(ItemType),
|
||||||
|
|
||||||
|
/// A union definition: `union Foo<A, B> { x: A, y: B }`.
|
||||||
|
Union(ItemUnion),
|
||||||
|
|
||||||
|
/// A use declaration: `use std::collections::HashMap`.
|
||||||
|
Use(ItemUse),
|
||||||
|
|
||||||
|
/// Tokens forming an item not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A constant item: `const MAX: u16 = 65535`.
|
||||||
|
pub struct ItemConst {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An enum definition: `enum Foo<A, B> { A(A), B(B) }`.
|
||||||
|
pub struct ItemEnum {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) variants: Punctuated<Variant>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An `extern crate` item: `extern crate serde`.
|
||||||
|
pub struct ItemExternCrate {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) rename: Option<Ident>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A free-standing function: `fn process(n: usize) -> Result<()> { ...
|
||||||
|
/// }`.
|
||||||
|
pub struct ItemFn {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) sig: Signature,
|
||||||
|
#[serde(rename = "stmts")]
|
||||||
|
pub(crate) block: Box<Block>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A block of foreign items: `extern "C" { ... }`.
|
||||||
|
pub struct ItemForeignMod {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) abi: Abi,
|
||||||
|
pub(crate) items: Vec<ForeignItem>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An impl block providing trait or associated items: `impl<A> Trait
|
||||||
|
/// for Data<A> { ... }`.
|
||||||
|
pub struct ItemImpl {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "default")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) defaultness: bool,
|
||||||
|
#[serde(rename = "unsafe")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) unsafety: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
/// Trait this impl implements.
|
||||||
|
#[serde(rename = "trait")]
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) trait_: Option<(bool, Path)>,
|
||||||
|
/// The Self type of the impl.
|
||||||
|
pub(crate) self_ty: Box<Type>,
|
||||||
|
pub(crate) items: Vec<ImplItem>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro invocation, which includes `macro_rules!` definitions.
|
||||||
|
pub struct ItemMacro {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
/// The `example` in `macro_rules! example { ... }`.
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) ident: Option<Ident>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) semi_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A 2.0-style declarative macro introduced by the `macro` keyword.
|
||||||
|
pub struct ItemMacro2 {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) rules: TokenStream,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A module or module declaration: `mod m` or `mod m { ... }`.
|
||||||
|
pub struct ItemMod {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) content: Option<Vec<Item>>,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) semi: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A static item: `static BIKE: Shed = Shed(42)`.
|
||||||
|
pub struct ItemStatic {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A struct definition: `struct Foo<A> { x: A }`.
|
||||||
|
pub struct ItemStruct {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) fields: Fields,
|
||||||
|
// #[serde(default, skip_serializing_if = "not")]
|
||||||
|
// pub(crate) semi_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A trait definition: `pub trait Iterator { ... }`.
|
||||||
|
pub struct ItemTrait {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(rename = "unsafe")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) unsafety: bool,
|
||||||
|
#[serde(rename = "auto")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) auto_token: bool,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Punctuated::is_empty")]
|
||||||
|
pub(crate) supertraits: Punctuated<TypeParamBound>,
|
||||||
|
pub(crate) items: Vec<TraitItem>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A trait alias: `pub trait SharableIterator = Iterator + Sync`.
|
||||||
|
pub struct ItemTraitAlias {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A type alias: `type Result<T> = std::result::Result<T, MyError>`.
|
||||||
|
pub struct ItemType {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A union definition: `union Foo<A, B> { x: A, y: B }`.
|
||||||
|
pub struct ItemUnion {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) fields: FieldsNamed,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A use declaration: `use std::collections::HashMap`.
|
||||||
|
pub struct ItemUse {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) leading_colon: bool,
|
||||||
|
pub(crate) tree: UseTree,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`.
|
||||||
|
pub enum UseTree {
|
||||||
|
/// A path prefix of imports in a `use` item: `std::...`.
|
||||||
|
Path(UsePath),
|
||||||
|
|
||||||
|
/// An identifier imported by a `use` item: `HashMap`.
|
||||||
|
#[serde(rename = "ident")]
|
||||||
|
Name(UseName),
|
||||||
|
|
||||||
|
/// An renamed identifier imported by a `use` item: `HashMap as Map`.
|
||||||
|
Rename(UseRename),
|
||||||
|
|
||||||
|
/// A glob import in a `use` item: `*`.
|
||||||
|
#[serde(rename = "*")]
|
||||||
|
Glob,
|
||||||
|
|
||||||
|
/// A braced group of imports in a `use` item: `{A, B, C}`.
|
||||||
|
Group(UseGroup),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A path prefix of imports in a `use` item: `std::...`.
|
||||||
|
pub struct UsePath {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) tree: Box<UseTree>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An identifier imported by a `use` item: `HashMap`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct UseName {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An renamed identifier imported by a `use` item: `HashMap as Map`.
|
||||||
|
pub struct UseRename {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) rename: Ident,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A braced group of imports in a `use` item: `{A, B, C}`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct UseGroup {
|
||||||
|
pub(crate) items: Punctuated<UseTree>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// An item within an `extern` block.
|
||||||
|
pub enum ForeignItem {
|
||||||
|
/// A foreign function in an `extern` block.
|
||||||
|
Fn(ForeignItemFn),
|
||||||
|
|
||||||
|
/// A foreign static item in an `extern` block: `static ext: u8`.
|
||||||
|
Static(ForeignItemStatic),
|
||||||
|
|
||||||
|
/// A foreign type in an `extern` block: `type void`.
|
||||||
|
Type(ForeignItemType),
|
||||||
|
|
||||||
|
/// A macro invocation within an extern block.
|
||||||
|
Macro(ForeignItemMacro),
|
||||||
|
|
||||||
|
/// Tokens in an `extern` block not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A foreign function in an `extern` block.
|
||||||
|
pub struct ForeignItemFn {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) sig: Signature,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A foreign static item in an `extern` block: `static ext: u8`.
|
||||||
|
pub struct ForeignItemStatic {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A foreign type in an `extern` block: `type void`.
|
||||||
|
pub struct ForeignItemType {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro invocation within an extern block.
|
||||||
|
pub struct ForeignItemMacro {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) semi_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// An item declaration within the definition of a trait.
|
||||||
|
pub enum TraitItem {
|
||||||
|
/// An associated constant within the definition of a trait.
|
||||||
|
Const(TraitItemConst),
|
||||||
|
|
||||||
|
/// A trait method within the definition of a trait.
|
||||||
|
Method(TraitItemMethod),
|
||||||
|
|
||||||
|
/// An associated type within the definition of a trait.
|
||||||
|
Type(TraitItemType),
|
||||||
|
|
||||||
|
/// A macro invocation within the definition of a trait.
|
||||||
|
Macro(TraitItemMacro),
|
||||||
|
|
||||||
|
/// Tokens within the definition of a trait not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An associated constant within the definition of a trait.
|
||||||
|
pub struct TraitItemConst {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) default: Option<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A trait method within the definition of a trait.
|
||||||
|
pub struct TraitItemMethod {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) sig: Signature,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) default: Option<Block>,
|
||||||
|
// #[serde(default, skip_serializing_if = "not")]
|
||||||
|
// pub(crate) semi_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An associated type within the definition of a trait.
|
||||||
|
pub struct TraitItemType {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Punctuated::is_empty")]
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) default: Option<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro invocation within the definition of a trait.
|
||||||
|
pub struct TraitItemMacro {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) semi_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// An item within an impl block.
|
||||||
|
pub enum ImplItem {
|
||||||
|
/// An associated constant within an impl block.
|
||||||
|
Const(ImplItemConst),
|
||||||
|
|
||||||
|
/// A method within an impl block.
|
||||||
|
Method(ImplItemMethod),
|
||||||
|
|
||||||
|
/// An associated type within an impl block.
|
||||||
|
Type(ImplItemType),
|
||||||
|
|
||||||
|
/// A macro invocation within an impl block.
|
||||||
|
Macro(ImplItemMacro),
|
||||||
|
|
||||||
|
/// Tokens within an impl block not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An associated constant within an impl block.
|
||||||
|
pub struct ImplItemConst {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(rename = "default")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) defaultness: bool,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
pub(crate) expr: Expr,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A method within an impl block.
|
||||||
|
pub struct ImplItemMethod {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(rename = "default")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) defaultness: bool,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) sig: Signature,
|
||||||
|
#[serde(rename = "stmts")]
|
||||||
|
pub(crate) block: Block,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An associated type within an impl block.
|
||||||
|
pub struct ImplItemType {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Visibility::is_inherited")]
|
||||||
|
pub(crate) vis: Visibility,
|
||||||
|
#[serde(rename = "default")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) defaultness: bool,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro invocation within an impl block.
|
||||||
|
pub struct ImplItemMacro {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) semi_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A function signature in a trait or implementation: `unsafe fn
|
||||||
|
/// initialize(&self)`.
|
||||||
|
pub struct Signature {
|
||||||
|
#[serde(rename = "const")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) constness: bool,
|
||||||
|
#[serde(rename = "async")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) asyncness: bool,
|
||||||
|
#[serde(rename = "unsafe")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) unsafety: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) abi: Option<Abi>,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Generics::is_none")]
|
||||||
|
pub(crate) generics: Generics,
|
||||||
|
pub(crate) inputs: Punctuated<FnArg>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) variadic: Option<Variadic>,
|
||||||
|
#[serde(default)]
|
||||||
|
pub(crate) output: ReturnType,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// An argument in a function signature: the `n: usize` in `fn f(n: usize)`.
|
||||||
|
pub enum FnArg {
|
||||||
|
/// The `self` argument of an associated method, whether taken by value
|
||||||
|
/// or by reference.
|
||||||
|
Receiver(Receiver),
|
||||||
|
|
||||||
|
/// A function argument accepted by pattern and type.
|
||||||
|
Typed(PatType),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// The `self` argument of an associated method, whether taken by value
|
||||||
|
/// or by reference.
|
||||||
|
pub struct Receiver {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "ref")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) reference: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) lifetime: Option<Lifetime>,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// ItemStruct
|
||||||
|
syn_trait_impl!(syn::ItemStruct);
|
||||||
|
impl From<&syn::ItemStruct> for ItemStruct {
|
||||||
|
fn from(other: &syn::ItemStruct) -> Self {
|
||||||
|
let fields: Fields = other.fields.ref_into();
|
||||||
|
assert_struct_semi(&fields, other.semi_token.is_some());
|
||||||
|
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
vis: other.vis.ref_into(),
|
||||||
|
ident: other.ident.ref_into(),
|
||||||
|
generics: other.generics.ref_into(),
|
||||||
|
fields,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&ItemStruct> for syn::ItemStruct {
|
||||||
|
fn from(other: &ItemStruct) -> Self {
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
vis: other.vis.ref_into(),
|
||||||
|
struct_token: default(),
|
||||||
|
ident: other.ident.ref_into(),
|
||||||
|
generics: other.generics.ref_into(),
|
||||||
|
fields: other.fields.ref_into(),
|
||||||
|
semi_token: default_or_none(!other.fields.is_named()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TraitItemMethod
|
||||||
|
syn_trait_impl!(syn::TraitItemMethod);
|
||||||
|
impl From<&syn::TraitItemMethod> for TraitItemMethod {
|
||||||
|
fn from(other: &syn::TraitItemMethod) -> Self {
|
||||||
|
if other.default.is_some() {
|
||||||
|
// `fn foo() -> bool {};`
|
||||||
|
assert!(other.semi_token.is_none(), "unexpected token: `;`");
|
||||||
|
} else {
|
||||||
|
// `fn foo() -> bool`
|
||||||
|
assert!(other.semi_token.is_some(), "expected `;`");
|
||||||
|
}
|
||||||
|
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
sig: other.sig.ref_into(),
|
||||||
|
default: other.default.map_into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&TraitItemMethod> for syn::TraitItemMethod {
|
||||||
|
fn from(other: &TraitItemMethod) -> Self {
|
||||||
|
Self {
|
||||||
|
attrs: other.attrs.map_into(),
|
||||||
|
sig: other.sig.ref_into(),
|
||||||
|
default: other.default.map_into(),
|
||||||
|
semi_token: default_or_none(other.default.is_none()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// UseTree
|
||||||
|
syn_trait_impl!(syn::UseTree);
|
||||||
|
impl From<&syn::UseTree> for UseTree {
|
||||||
|
fn from(other: &syn::UseTree) -> Self {
|
||||||
|
use super::UseTree::*;
|
||||||
|
use syn::UseTree;
|
||||||
|
match other {
|
||||||
|
UseTree::Path(x) => Path(x.into()),
|
||||||
|
UseTree::Name(x) => Name(x.into()),
|
||||||
|
UseTree::Rename(x) => Rename(x.into()),
|
||||||
|
UseTree::Glob(_) => Glob,
|
||||||
|
UseTree::Group(x) => Group(x.into()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&UseTree> for syn::UseTree {
|
||||||
|
fn from(other: &UseTree) -> Self {
|
||||||
|
use syn::UseTree::*;
|
||||||
|
match other {
|
||||||
|
UseTree::Path(x) => Path(x.into()),
|
||||||
|
UseTree::Name(x) => Name(x.into()),
|
||||||
|
UseTree::Rename(x) => Rename(x.into()),
|
||||||
|
UseTree::Glob => Glob(syn::UseGlob {
|
||||||
|
star_token: default(),
|
||||||
|
}),
|
||||||
|
UseTree::Group(x) => Group(x.into()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Receiver
|
||||||
|
syn_trait_impl!(syn::Receiver);
|
||||||
|
impl From<&syn::Receiver> for Receiver {
|
||||||
|
fn from(node: &syn::Receiver) -> Self {
|
||||||
|
Receiver {
|
||||||
|
attrs: node.attrs.map_into(),
|
||||||
|
reference: node.reference.is_some(),
|
||||||
|
lifetime: node.reference.as_ref().and_then(|(_0, _1)| _1.map_into()),
|
||||||
|
mutability: node.mutability.is_some(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Receiver> for syn::Receiver {
|
||||||
|
fn from(node: &Receiver) -> Self {
|
||||||
|
syn::Receiver {
|
||||||
|
attrs: node.attrs.map_into(),
|
||||||
|
reference: if node.reference {
|
||||||
|
Some((default(), node.lifetime.map_into()))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
},
|
||||||
|
mutability: default_or_none(node.mutability),
|
||||||
|
self_token: default(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
210
syn-serde/src/json.rs
Normal file
210
syn-serde/src/json.rs
Normal file
|
|
@ -0,0 +1,210 @@
|
||||||
|
//! A module to provide functions for JSON <-> Rust serialize and deserialize.
|
||||||
|
//!
|
||||||
|
//! *This module is available if syn-serde is built with the `"json"` feature.*
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
use serde_json::Result;
|
||||||
|
use std::io;
|
||||||
|
|
||||||
|
// Serialize [`Syn`] type into JSON data.
|
||||||
|
|
||||||
|
/// Serialize the given [`Syn`] type as JSON into the IO stream.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # use std::io;
|
||||||
|
/// # fn to_writer<W>(writer: W, syn_file: &syn::File) -> serde_json::Result<()>
|
||||||
|
/// # where
|
||||||
|
/// # W: io::Write,
|
||||||
|
/// # {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// serde_json::to_writer(writer, &serializable_file)
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn to_writer<S, W>(writer: W, syn: &S) -> Result<()>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
W: io::Write,
|
||||||
|
{
|
||||||
|
let adapter = syn.to_adapter();
|
||||||
|
serde_json::to_writer(writer, &adapter)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize the given [`Syn`] type as pretty-printed JSON into the IO
|
||||||
|
/// stream.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # use std::io;
|
||||||
|
/// # fn to_writer_pretty<W: io::Write>(writer: W, syn_file: &syn::File) -> serde_json::Result<()> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// serde_json::to_writer_pretty(writer, &serializable_file)
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn to_writer_pretty<S, W>(writer: W, syn: &S) -> Result<()>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
W: io::Write,
|
||||||
|
{
|
||||||
|
let adapter = syn.to_adapter();
|
||||||
|
serde_json::to_writer_pretty(writer, &adapter)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize the given [`Syn`] type as a JSON byte vector.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # fn to_vec(syn_file: &syn::File) -> Vec<u8> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// serde_json::to_vec(&serializable_file).unwrap()
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn to_vec<S>(syn: &S) -> Vec<u8>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
{
|
||||||
|
let adapter = syn.to_adapter();
|
||||||
|
serde_json::to_vec(&adapter).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize the given [`Syn`] type as a pretty-printed JSON byte vector.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # fn to_vec_pretty(syn_file: &syn::File) -> Vec<u8> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// serde_json::to_vec_pretty(&serializable_file).unwrap()
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn to_vec_pretty<S>(syn: &S) -> Vec<u8>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
{
|
||||||
|
let adapter = syn.to_adapter();
|
||||||
|
serde_json::to_vec_pretty(&adapter).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize the given [`Syn`] type as a String of JSON.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # fn to_string(syn_file: &syn::File) -> String {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// serde_json::to_string(&serializable_file).unwrap()
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn to_string<S>(syn: &S) -> String
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
{
|
||||||
|
let adapter = syn.to_adapter();
|
||||||
|
serde_json::to_string(&adapter).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Serialize the given [`Syn`] type as a pretty-printed String of JSON.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # fn to_string_pretty(syn_file: &syn::File) -> String {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// serde_json::to_string_pretty(&serializable_file).unwrap()
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn to_string_pretty<S>(syn: &S) -> String
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
{
|
||||||
|
let adapter = syn.to_adapter();
|
||||||
|
serde_json::to_string_pretty(&adapter).unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
// Deserialize JSON data to [`Syn`] type.
|
||||||
|
|
||||||
|
/// Deserialize an instance of [`Syn`] type from an IO stream of JSON.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # use std::io;
|
||||||
|
/// # fn from_reader<R: io::Read>(rdr: R) -> serde_json::Result<syn::File> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file: <syn::File as Syn>::Adapter = serde_json::from_reader(rdr)?;
|
||||||
|
/// let syn_file = syn::File::from_adapter(&serializable_file);
|
||||||
|
/// Ok(syn_file)
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
pub fn from_reader<S, R>(rdr: R) -> Result<S>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
R: io::Read,
|
||||||
|
{
|
||||||
|
let adapter: S::Adapter = serde_json::from_reader(rdr)?;
|
||||||
|
Ok(S::from_adapter(&adapter))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Deserialize an instance of [`Syn`] type from bytes of JSON text.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # fn from_reader(v: &[u8]) -> serde_json::Result<syn::File> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file: <syn::File as Syn>::Adapter = serde_json::from_slice(v)?;
|
||||||
|
/// let syn_file = syn::File::from_adapter(&serializable_file);
|
||||||
|
/// Ok(syn_file)
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
pub fn from_slice<S>(v: &[u8]) -> Result<S>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
{
|
||||||
|
let adapter: S::Adapter = serde_json::from_slice(v)?;
|
||||||
|
Ok(S::from_adapter(&adapter))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Deserialize an instance of [`Syn`] type from a string of JSON text.
|
||||||
|
///
|
||||||
|
/// This function is equivalent to the following code:
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # fn from_str(s: &str) -> serde_json::Result<syn::File> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let serializable_file: <syn::File as Syn>::Adapter = serde_json::from_str(s)?;
|
||||||
|
/// let syn_file = syn::File::from_adapter(&serializable_file);
|
||||||
|
/// Ok(syn_file)
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
pub fn from_str<S>(s: &str) -> Result<S>
|
||||||
|
where
|
||||||
|
S: Syn,
|
||||||
|
{
|
||||||
|
let adapter: S::Adapter = serde_json::from_str(s)?;
|
||||||
|
Ok(S::from_adapter(&adapter))
|
||||||
|
}
|
||||||
350
syn-serde/src/lib.rs
Normal file
350
syn-serde/src/lib.rs
Normal file
|
|
@ -0,0 +1,350 @@
|
||||||
|
//! Library to serialize and deserialize [Syn] syntax trees.
|
||||||
|
//!
|
||||||
|
//! ## Examples
|
||||||
|
//!
|
||||||
|
//! ```toml
|
||||||
|
//! [dependencies]
|
||||||
|
//! syn-serde = { version = "0.2", features = ["json"] }
|
||||||
|
//! syn = { version = "1", features = ["full"] }
|
||||||
|
//! ```
|
||||||
|
//!
|
||||||
|
//! ```rust
|
||||||
|
//! # #[cfg(feature = "json")]
|
||||||
|
//! # fn dox() -> Result<(), Box<dyn std::error::Error>> {
|
||||||
|
//! use syn_serde::json;
|
||||||
|
//!
|
||||||
|
//! let syn_file: syn::File = syn::parse_quote! {
|
||||||
|
//! fn main() {
|
||||||
|
//! println!("Hello, world!");
|
||||||
|
//! }
|
||||||
|
//! };
|
||||||
|
//! println!("{}", json::to_string_pretty(&syn_file));
|
||||||
|
//! # Ok(())
|
||||||
|
//! # }
|
||||||
|
//! ```
|
||||||
|
//!
|
||||||
|
//! This prints the following JSON:
|
||||||
|
//!
|
||||||
|
//! ```json
|
||||||
|
//! {
|
||||||
|
//! "items": [
|
||||||
|
//! {
|
||||||
|
//! "fn": {
|
||||||
|
//! "ident": "main",
|
||||||
|
//! "inputs": [],
|
||||||
|
//! "output": null,
|
||||||
|
//! "stmts": [
|
||||||
|
//! {
|
||||||
|
//! "semi": {
|
||||||
|
//! "macro": {
|
||||||
|
//! "path": {
|
||||||
|
//! "segments": [
|
||||||
|
//! {
|
||||||
|
//! "ident": "println"
|
||||||
|
//! }
|
||||||
|
//! ]
|
||||||
|
//! },
|
||||||
|
//! "delimiter": "paren",
|
||||||
|
//! "tokens": [
|
||||||
|
//! {
|
||||||
|
//! "lit": "\"Hello, world!\""
|
||||||
|
//! }
|
||||||
|
//! ]
|
||||||
|
//! }
|
||||||
|
//! }
|
||||||
|
//! }
|
||||||
|
//! ]
|
||||||
|
//! }
|
||||||
|
//! }
|
||||||
|
//! ]
|
||||||
|
//! }
|
||||||
|
//! ```
|
||||||
|
//!
|
||||||
|
//! ### Rust source file -> JSON representation of the syntax tree
|
||||||
|
//!
|
||||||
|
//! The [`rust2json`] example parse a Rust source file into a `syn_serde::File`
|
||||||
|
//! and print out a JSON representation of the syntax tree.
|
||||||
|
//!
|
||||||
|
//! ### JSON file -> Rust syntax tree
|
||||||
|
//!
|
||||||
|
//! The [`json2rust`] example parse a JSON file into a `syn_serde::File` and
|
||||||
|
//! print out a Rust syntax tree.
|
||||||
|
//!
|
||||||
|
//! ## Optional features
|
||||||
|
//!
|
||||||
|
//! - **`json`** — Provides functions for JSON <-> Rust serializing and
|
||||||
|
//! deserializing.
|
||||||
|
//!
|
||||||
|
//! [Syn]: https://github.com/dtolnay/syn
|
||||||
|
//! [`rust2json`]: https://github.com/taiki-e/syn-serde/tree/master/examples/rust2json
|
||||||
|
//! [`json2rust`]: https://github.com/taiki-e/syn-serde/tree/master/examples/json2rust
|
||||||
|
|
||||||
|
#![doc(html_root_url = "https://docs.rs/syn-serde/0.2.0")]
|
||||||
|
#![doc(test(
|
||||||
|
no_crate_inject,
|
||||||
|
attr(
|
||||||
|
deny(warnings, rust_2018_idioms, single_use_lifetimes),
|
||||||
|
allow(dead_code)
|
||||||
|
)
|
||||||
|
))]
|
||||||
|
#![forbid(unsafe_code)]
|
||||||
|
#![warn(rust_2018_idioms, unreachable_pub)]
|
||||||
|
// It cannot be included in the published code because these lints have false positives in the minimum required version.
|
||||||
|
#![cfg_attr(test, warn(single_use_lifetimes))]
|
||||||
|
#![warn(clippy::all)]
|
||||||
|
// mem::take requires Rust 1.40
|
||||||
|
#![allow(clippy::mem_replace_with_default)]
|
||||||
|
#![allow(clippy::large_enum_variant, clippy::needless_doctest_main)]
|
||||||
|
|
||||||
|
#[macro_use]
|
||||||
|
mod macros;
|
||||||
|
|
||||||
|
mod gen;
|
||||||
|
|
||||||
|
mod attr;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::attr::*;
|
||||||
|
|
||||||
|
mod data;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::data::*;
|
||||||
|
|
||||||
|
mod expr;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::expr::*;
|
||||||
|
|
||||||
|
mod generics;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::generics::*;
|
||||||
|
|
||||||
|
mod item;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::item::*;
|
||||||
|
|
||||||
|
mod file;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::file::File;
|
||||||
|
|
||||||
|
mod lifetime;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::lifetime::Lifetime;
|
||||||
|
|
||||||
|
mod lit;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::lit::*;
|
||||||
|
|
||||||
|
mod mac;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::mac::{Macro, MacroDelimiter};
|
||||||
|
|
||||||
|
mod op;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::op::{BinOp, UnOp};
|
||||||
|
|
||||||
|
mod ty;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::ty::*;
|
||||||
|
|
||||||
|
mod pat;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::pat::*;
|
||||||
|
|
||||||
|
mod path;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::path::*;
|
||||||
|
|
||||||
|
mod stmt;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::stmt::{Block, Local, Stmt};
|
||||||
|
|
||||||
|
mod token_stream;
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub use crate::token_stream::{
|
||||||
|
Delimiter, Group, Ident, Literal, Punct, Spacing, TokenStream, TokenTree,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[cfg(feature = "json")]
|
||||||
|
pub mod json;
|
||||||
|
|
||||||
|
// =============================================================================
|
||||||
|
// Syn trait
|
||||||
|
|
||||||
|
mod private {
|
||||||
|
pub trait Sealed {}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A trait for the data structures of [Syn] and [proc-macro2].
|
||||||
|
///
|
||||||
|
/// [Syn]: https://github.com/dtolnay/syn
|
||||||
|
/// [proc-macro2]: https://github.com/alexcrichton/proc-macro2
|
||||||
|
#[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
|
||||||
|
pub trait Syn: Sized + private::Sealed {
|
||||||
|
type Adapter: Serialize + for<'de> Deserialize<'de>;
|
||||||
|
|
||||||
|
/// Converts a `Syn` type into an adapter.
|
||||||
|
///
|
||||||
|
/// ## Examples
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # #[cfg(feature = "json")]
|
||||||
|
/// # fn dox() {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// let syn_file: syn::File = syn::parse_quote! {
|
||||||
|
/// fn main() {
|
||||||
|
/// println!("Hello, world!");
|
||||||
|
/// }
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// let serializable_file = syn_file.to_adapter();
|
||||||
|
/// println!("{}", serde_json::to_string_pretty(&serializable_file).unwrap());
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
fn to_adapter(&self) -> Self::Adapter;
|
||||||
|
|
||||||
|
/// Converts an adapter into a `Syn` type.
|
||||||
|
///
|
||||||
|
/// ## Examples
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// # #[cfg(feature = "json")]
|
||||||
|
/// # fn dox() -> Result<(), Box<dyn std::error::Error>> {
|
||||||
|
/// use syn_serde::Syn;
|
||||||
|
///
|
||||||
|
/// // `struct Unit;`
|
||||||
|
/// let json = r#"{
|
||||||
|
/// "struct": {
|
||||||
|
/// "ident": "Unit",
|
||||||
|
/// "fields": "unit"
|
||||||
|
/// }
|
||||||
|
/// }"#;
|
||||||
|
///
|
||||||
|
/// let serializable_file: <syn::File as Syn>::Adapter = serde_json::from_str(json)?;
|
||||||
|
/// let _syn_file = syn::File::from_adapter(&serializable_file);
|
||||||
|
/// # Ok(())
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
fn from_adapter(adapter: &Self::Adapter) -> Self;
|
||||||
|
}
|
||||||
|
|
||||||
|
// =============================================================================
|
||||||
|
|
||||||
|
use proc_macro2::Span;
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
type Punctuated<T> = Vec<T>;
|
||||||
|
|
||||||
|
fn default<T>() -> T
|
||||||
|
where
|
||||||
|
T: Default,
|
||||||
|
{
|
||||||
|
T::default()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn default_or_none<T>(x: bool) -> Option<T>
|
||||||
|
where
|
||||||
|
T: Default,
|
||||||
|
{
|
||||||
|
if x {
|
||||||
|
Some(T::default())
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn not<T>(x: T) -> T::Output
|
||||||
|
where
|
||||||
|
T: std::ops::Not,
|
||||||
|
{
|
||||||
|
!x
|
||||||
|
}
|
||||||
|
|
||||||
|
// https://github.com/rust-lang/rust/issues/51443
|
||||||
|
trait RefInto<U>: Sized {
|
||||||
|
fn ref_into<'a>(&'a self) -> U
|
||||||
|
where
|
||||||
|
&'a Self: Into<U>,
|
||||||
|
{
|
||||||
|
self.into()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T, U> RefInto<U> for T {}
|
||||||
|
|
||||||
|
trait MapInto<U, M> {
|
||||||
|
type T;
|
||||||
|
|
||||||
|
fn ref_map<'a, F>(&'a self, f: F) -> M
|
||||||
|
where
|
||||||
|
Self::T: 'a,
|
||||||
|
F: FnMut(&'a Self::T) -> U;
|
||||||
|
|
||||||
|
fn map_into<'a>(&'a self) -> M
|
||||||
|
where
|
||||||
|
Self::T: 'a,
|
||||||
|
&'a Self::T: Into<U>,
|
||||||
|
{
|
||||||
|
self.ref_map(Into::into)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T, U> MapInto<U, Vec<U>> for Vec<T> {
|
||||||
|
type T = T;
|
||||||
|
|
||||||
|
fn ref_map<'a, F>(&'a self, f: F) -> Vec<U>
|
||||||
|
where
|
||||||
|
F: FnMut(&'a Self::T) -> U,
|
||||||
|
{
|
||||||
|
self.iter().map(f).collect()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T, U, P> MapInto<U, syn::punctuated::Punctuated<U, P>> for Vec<T>
|
||||||
|
where
|
||||||
|
P: Default,
|
||||||
|
{
|
||||||
|
type T = T;
|
||||||
|
|
||||||
|
fn ref_map<'a, F>(&'a self, f: F) -> syn::punctuated::Punctuated<U, P>
|
||||||
|
where
|
||||||
|
F: FnMut(&'a Self::T) -> U,
|
||||||
|
{
|
||||||
|
self.iter().map(f).collect()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T, U, P> MapInto<U, Vec<U>> for syn::punctuated::Punctuated<T, P>
|
||||||
|
where
|
||||||
|
P: Default,
|
||||||
|
{
|
||||||
|
type T = T;
|
||||||
|
|
||||||
|
fn ref_map<'a, F>(&'a self, f: F) -> Vec<U>
|
||||||
|
where
|
||||||
|
F: FnMut(&'a Self::T) -> U,
|
||||||
|
{
|
||||||
|
self.iter().map(f).collect()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T, U> MapInto<U, Option<U>> for Option<T> {
|
||||||
|
type T = T;
|
||||||
|
|
||||||
|
fn ref_map<'a, F>(&'a self, f: F) -> Option<U>
|
||||||
|
where
|
||||||
|
F: FnMut(&'a Self::T) -> U,
|
||||||
|
{
|
||||||
|
self.as_ref().map(f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T, U> MapInto<U, Box<U>> for Box<T> {
|
||||||
|
type T = T;
|
||||||
|
|
||||||
|
fn ref_map<'a, F>(&'a self, mut f: F) -> Box<U>
|
||||||
|
where
|
||||||
|
F: FnMut(&'a Self::T) -> U,
|
||||||
|
{
|
||||||
|
Box::new(f(&**self))
|
||||||
|
}
|
||||||
|
}
|
||||||
19
syn-serde/src/lifetime.rs
Normal file
19
syn-serde/src/lifetime.rs
Normal file
|
|
@ -0,0 +1,19 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A Rust lifetime: `'a`.
|
||||||
|
///
|
||||||
|
/// Lifetime names must conform to the following rules:
|
||||||
|
///
|
||||||
|
/// - Must start with an apostrophe.
|
||||||
|
/// - Must not consist of just an apostrophe: `'`.
|
||||||
|
/// - 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.
|
||||||
|
#[derive(Clone)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Lifetime {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
}
|
||||||
|
}
|
||||||
525
syn-serde/src/lit.rs
Normal file
525
syn-serde/src/lit.rs
Normal file
|
|
@ -0,0 +1,525 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A Rust literal such as a string or integer or boolean.
|
||||||
|
pub enum Lit {
|
||||||
|
/// A UTF-8 string literal: `"foo"`.
|
||||||
|
Str(LitStr),
|
||||||
|
|
||||||
|
/// A byte string literal: `b"foo"`.
|
||||||
|
ByteStr(LitByteStr),
|
||||||
|
|
||||||
|
/// A byte literal: `b'f'`.
|
||||||
|
Byte(LitByte),
|
||||||
|
|
||||||
|
/// A character literal: `'a'`.
|
||||||
|
Char(LitChar),
|
||||||
|
|
||||||
|
/// An integer literal: `1` or `1u16`.
|
||||||
|
Int(LitInt),
|
||||||
|
|
||||||
|
/// A floating point literal: `1f64` or `1.0e10f64`.
|
||||||
|
///
|
||||||
|
/// Must be finite. May not be infinte or NaN.
|
||||||
|
Float(LitFloat),
|
||||||
|
|
||||||
|
/// A boolean literal: `true` or `false`.
|
||||||
|
Bool(LitBool),
|
||||||
|
|
||||||
|
/// A raw token literal not interpreted by Syn.
|
||||||
|
Verbatim(Literal),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A UTF-8 string literal: `"foo"`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitStr {
|
||||||
|
token: Literal,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A byte string literal: `b"foo"`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitByteStr {
|
||||||
|
token: Literal,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A byte literal: `b'f'`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitByte {
|
||||||
|
token: Literal,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A character literal: `'a'`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitChar {
|
||||||
|
token: Literal,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An integer literal: `1` or `1u16`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitInt {
|
||||||
|
token: Literal,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A floating point literal: `1f64` or `1.0e10f64`.
|
||||||
|
///
|
||||||
|
/// Must be finite. May not be infinte or NaN.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitFloat {
|
||||||
|
token: Literal,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A boolean literal: `true` or `false`.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct LitBool {
|
||||||
|
pub(crate) value: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// The style of a string literal, either plain quoted or a raw string like
|
||||||
|
/// `r##"data"##`.
|
||||||
|
pub enum StrStyle {
|
||||||
|
/// An ordinary string like `"data"`.
|
||||||
|
Cooked,
|
||||||
|
/// A raw string like `r##"data"##`.
|
||||||
|
///
|
||||||
|
/// The unsigned integer is the number of `#` symbols used.
|
||||||
|
Raw(usize),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod value {
|
||||||
|
use super::*;
|
||||||
|
use proc_macro2::{TokenStream, TokenTree};
|
||||||
|
use std::{
|
||||||
|
char,
|
||||||
|
ops::{Index, RangeFrom},
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Get the byte at offset idx, or a default of `b'\0'` if we're looking
|
||||||
|
/// past the end of the input buffer.
|
||||||
|
pub(crate) fn byte<S: AsRef<[u8]> + ?Sized>(s: &S, idx: usize) -> u8 {
|
||||||
|
let s = s.as_ref();
|
||||||
|
if idx < s.len() {
|
||||||
|
s[idx]
|
||||||
|
} else {
|
||||||
|
0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn next_chr(s: &str) -> char {
|
||||||
|
s.chars().next().unwrap_or('\0')
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns (content, suffix).
|
||||||
|
pub(crate) fn parse_lit_str(s: &str) -> (Box<str>, Box<str>) {
|
||||||
|
match byte(s, 0) {
|
||||||
|
b'"' => parse_lit_str_cooked(s),
|
||||||
|
b'r' => parse_lit_str_raw(s),
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_lit_str_cooked(mut s: &str) -> (Box<str>, Box<str>) {
|
||||||
|
assert_eq!(byte(s, 0), b'"');
|
||||||
|
s = &s[1..];
|
||||||
|
|
||||||
|
let mut content = String::new();
|
||||||
|
'outer: loop {
|
||||||
|
let ch = match byte(s, 0) {
|
||||||
|
b'"' => break,
|
||||||
|
b'\\' => {
|
||||||
|
let b = byte(s, 1);
|
||||||
|
s = &s[2..];
|
||||||
|
match b {
|
||||||
|
b'x' => {
|
||||||
|
let (byte, rest) = backslash_x(s);
|
||||||
|
s = rest;
|
||||||
|
assert!(byte <= 0x80, "Invalid \\x byte in string literal");
|
||||||
|
char::from_u32(u32::from(byte)).unwrap()
|
||||||
|
}
|
||||||
|
b'u' => {
|
||||||
|
let (chr, rest) = backslash_u(s);
|
||||||
|
s = rest;
|
||||||
|
chr
|
||||||
|
}
|
||||||
|
b'n' => '\n',
|
||||||
|
b'r' => '\r',
|
||||||
|
b't' => '\t',
|
||||||
|
b'\\' => '\\',
|
||||||
|
b'0' => '\0',
|
||||||
|
b'\'' => '\'',
|
||||||
|
b'"' => '"',
|
||||||
|
b'\r' | b'\n' => loop {
|
||||||
|
let ch = next_chr(s);
|
||||||
|
if ch.is_whitespace() {
|
||||||
|
s = &s[ch.len_utf8()..];
|
||||||
|
} else {
|
||||||
|
continue 'outer;
|
||||||
|
}
|
||||||
|
},
|
||||||
|
b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
b'\r' => {
|
||||||
|
assert_eq!(byte(s, 1), b'\n', "Bare CR not allowed in string");
|
||||||
|
s = &s[2..];
|
||||||
|
'\n'
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
let ch = next_chr(s);
|
||||||
|
s = &s[ch.len_utf8()..];
|
||||||
|
ch
|
||||||
|
}
|
||||||
|
};
|
||||||
|
content.push(ch);
|
||||||
|
}
|
||||||
|
|
||||||
|
assert!(s.starts_with('"'));
|
||||||
|
let content = content.into_boxed_str();
|
||||||
|
let suffix = s[1..].to_owned().into_boxed_str();
|
||||||
|
(content, suffix)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_lit_str_raw(mut s: &str) -> (Box<str>, Box<str>) {
|
||||||
|
assert_eq!(byte(s, 0), b'r');
|
||||||
|
s = &s[1..];
|
||||||
|
|
||||||
|
let mut pounds = 0;
|
||||||
|
while byte(s, pounds) == b'#' {
|
||||||
|
pounds += 1;
|
||||||
|
}
|
||||||
|
assert_eq!(byte(s, pounds), b'"');
|
||||||
|
assert_eq!(byte(s, s.len() - pounds - 1), b'"');
|
||||||
|
for end in s[s.len() - pounds..].bytes() {
|
||||||
|
assert_eq!(end, b'#');
|
||||||
|
}
|
||||||
|
|
||||||
|
let content = s[pounds + 1..s.len() - pounds - 1]
|
||||||
|
.to_owned()
|
||||||
|
.into_boxed_str();
|
||||||
|
let suffix = Box::<str>::default(); // todo
|
||||||
|
(content, suffix)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn parse_lit_byte_str(s: &str) -> Vec<u8> {
|
||||||
|
assert_eq!(byte(s, 0), b'b');
|
||||||
|
match byte(s, 1) {
|
||||||
|
b'"' => parse_lit_byte_str_cooked(s),
|
||||||
|
b'r' => parse_lit_byte_str_raw(s),
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_lit_byte_str_cooked(mut s: &str) -> Vec<u8> {
|
||||||
|
assert_eq!(byte(s, 0), b'b');
|
||||||
|
assert_eq!(byte(s, 1), b'"');
|
||||||
|
s = &s[2..];
|
||||||
|
|
||||||
|
// We're going to want to have slices which don't respect codepoint boundaries.
|
||||||
|
let mut s = s.as_bytes();
|
||||||
|
|
||||||
|
let mut out = Vec::new();
|
||||||
|
'outer: loop {
|
||||||
|
let byte = match byte(s, 0) {
|
||||||
|
b'"' => break,
|
||||||
|
b'\\' => {
|
||||||
|
let b = byte(s, 1);
|
||||||
|
s = &s[2..];
|
||||||
|
match b {
|
||||||
|
b'x' => {
|
||||||
|
let (b, rest) = backslash_x(s);
|
||||||
|
s = rest;
|
||||||
|
b
|
||||||
|
}
|
||||||
|
b'n' => b'\n',
|
||||||
|
b'r' => b'\r',
|
||||||
|
b't' => b'\t',
|
||||||
|
b'\\' => b'\\',
|
||||||
|
b'0' => b'\0',
|
||||||
|
b'\'' => b'\'',
|
||||||
|
b'"' => b'"',
|
||||||
|
b'\r' | b'\n' => loop {
|
||||||
|
let byte = byte(s, 0);
|
||||||
|
let ch = char::from_u32(u32::from(byte)).unwrap();
|
||||||
|
if ch.is_whitespace() {
|
||||||
|
s = &s[1..];
|
||||||
|
} else {
|
||||||
|
continue 'outer;
|
||||||
|
}
|
||||||
|
},
|
||||||
|
b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
b'\r' => {
|
||||||
|
assert_eq!(byte(s, 1), b'\n', "Bare CR not allowed in string");
|
||||||
|
s = &s[2..];
|
||||||
|
b'\n'
|
||||||
|
}
|
||||||
|
b => {
|
||||||
|
s = &s[1..];
|
||||||
|
b
|
||||||
|
}
|
||||||
|
};
|
||||||
|
out.push(byte);
|
||||||
|
}
|
||||||
|
|
||||||
|
assert_eq!(s, b"\"");
|
||||||
|
out
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_lit_byte_str_raw(s: &str) -> Vec<u8> {
|
||||||
|
assert_eq!(byte(s, 0), b'b');
|
||||||
|
String::from(parse_lit_str_raw(&s[1..]).0).into_bytes()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn parse_lit_byte(s: &str) -> u8 {
|
||||||
|
assert_eq!(byte(s, 0), b'b');
|
||||||
|
assert_eq!(byte(s, 1), b'\'');
|
||||||
|
|
||||||
|
// We're going to want to have slices which don't respect codepoint boundaries.
|
||||||
|
let mut s = s[2..].as_bytes();
|
||||||
|
|
||||||
|
let b = match byte(s, 0) {
|
||||||
|
b'\\' => {
|
||||||
|
let b = byte(s, 1);
|
||||||
|
s = &s[2..];
|
||||||
|
match b {
|
||||||
|
b'x' => {
|
||||||
|
let (b, rest) = backslash_x(s);
|
||||||
|
s = rest;
|
||||||
|
b
|
||||||
|
}
|
||||||
|
b'n' => b'\n',
|
||||||
|
b'r' => b'\r',
|
||||||
|
b't' => b'\t',
|
||||||
|
b'\\' => b'\\',
|
||||||
|
b'0' => b'\0',
|
||||||
|
b'\'' => b'\'',
|
||||||
|
b'"' => b'"',
|
||||||
|
b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
b => {
|
||||||
|
s = &s[1..];
|
||||||
|
b
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
assert_eq!(byte(s, 0), b'\'');
|
||||||
|
b
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn parse_lit_char(mut s: &str) -> char {
|
||||||
|
assert_eq!(byte(s, 0), b'\'');
|
||||||
|
s = &s[1..];
|
||||||
|
|
||||||
|
let ch = if byte(s, 0) == b'\\' {
|
||||||
|
let b = byte(s, 1);
|
||||||
|
s = &s[2..];
|
||||||
|
match b {
|
||||||
|
b'x' => {
|
||||||
|
let (byte, rest) = backslash_x(s);
|
||||||
|
s = rest;
|
||||||
|
assert!(byte <= 0x80, "Invalid \\x byte in string literal");
|
||||||
|
char::from_u32(u32::from(byte)).unwrap()
|
||||||
|
}
|
||||||
|
b'u' => {
|
||||||
|
let (chr, rest) = backslash_u(s);
|
||||||
|
s = rest;
|
||||||
|
chr
|
||||||
|
}
|
||||||
|
b'n' => '\n',
|
||||||
|
b'r' => '\r',
|
||||||
|
b't' => '\t',
|
||||||
|
b'\\' => '\\',
|
||||||
|
b'0' => '\0',
|
||||||
|
b'\'' => '\'',
|
||||||
|
b'"' => '"',
|
||||||
|
b => panic!("unexpected byte {:?} after \\ character in byte literal", b),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
let ch = next_chr(s);
|
||||||
|
s = &s[ch.len_utf8()..];
|
||||||
|
ch
|
||||||
|
};
|
||||||
|
assert_eq!(s, "\'", "Expected end of char literal");
|
||||||
|
ch
|
||||||
|
}
|
||||||
|
|
||||||
|
fn backslash_x<S>(s: &S) -> (u8, &S)
|
||||||
|
where
|
||||||
|
S: Index<RangeFrom<usize>, Output = S> + AsRef<[u8]> + ?Sized,
|
||||||
|
{
|
||||||
|
let mut ch = 0;
|
||||||
|
let b0 = byte(s, 0);
|
||||||
|
let b1 = byte(s, 1);
|
||||||
|
ch += 0x10
|
||||||
|
* match b0 {
|
||||||
|
b'0'..=b'9' => b0 - b'0',
|
||||||
|
b'a'..=b'f' => 10 + (b0 - b'a'),
|
||||||
|
b'A'..=b'F' => 10 + (b0 - b'A'),
|
||||||
|
_ => panic!("unexpected non-hex character after \\x"),
|
||||||
|
};
|
||||||
|
ch += match b1 {
|
||||||
|
b'0'..=b'9' => b1 - b'0',
|
||||||
|
b'a'..=b'f' => 10 + (b1 - b'a'),
|
||||||
|
b'A'..=b'F' => 10 + (b1 - b'A'),
|
||||||
|
_ => panic!("unexpected non-hex character after \\x"),
|
||||||
|
};
|
||||||
|
(ch, &s[2..])
|
||||||
|
}
|
||||||
|
|
||||||
|
fn backslash_u(mut s: &str) -> (char, &str) {
|
||||||
|
if byte(s, 0) != b'{' {
|
||||||
|
panic!("expected {{ after \\u");
|
||||||
|
}
|
||||||
|
s = &s[1..];
|
||||||
|
|
||||||
|
let mut ch = 0;
|
||||||
|
for _ in 0..6 {
|
||||||
|
let b = byte(s, 0);
|
||||||
|
match b {
|
||||||
|
b'0'..=b'9' => {
|
||||||
|
ch *= 0x10;
|
||||||
|
ch += u32::from(b - b'0');
|
||||||
|
s = &s[1..];
|
||||||
|
}
|
||||||
|
b'a'..=b'f' => {
|
||||||
|
ch *= 0x10;
|
||||||
|
ch += u32::from(10 + b - b'a');
|
||||||
|
s = &s[1..];
|
||||||
|
}
|
||||||
|
b'A'..=b'F' => {
|
||||||
|
ch *= 0x10;
|
||||||
|
ch += u32::from(10 + b - b'A');
|
||||||
|
s = &s[1..];
|
||||||
|
}
|
||||||
|
b'}' => break,
|
||||||
|
_ => panic!("unexpected non-hex character after \\u"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert!(byte(s, 0) == b'}');
|
||||||
|
s = &s[1..];
|
||||||
|
|
||||||
|
if let Some(ch) = char::from_u32(ch) {
|
||||||
|
(ch, s)
|
||||||
|
} else {
|
||||||
|
panic!("character code {:x} is not a valid unicode character", ch);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn to_literal(s: &str) -> Literal {
|
||||||
|
let stream = s.parse::<TokenStream>().unwrap();
|
||||||
|
match stream.into_iter().next().unwrap() {
|
||||||
|
TokenTree::Literal(l) => l.ref_into(),
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// LitStr
|
||||||
|
impl From<&syn::LitStr> for LitStr {
|
||||||
|
fn from(other: &syn::LitStr) -> Self {
|
||||||
|
Self {
|
||||||
|
token: Literal::string(&other.value()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&LitStr> for syn::LitStr {
|
||||||
|
fn from(other: &LitStr) -> Self {
|
||||||
|
let (value, _) = value::parse_lit_str(&other.token.text);
|
||||||
|
Self::new(&value, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// LitByteStr
|
||||||
|
impl From<&syn::LitByteStr> for LitByteStr {
|
||||||
|
fn from(other: &syn::LitByteStr) -> Self {
|
||||||
|
Self {
|
||||||
|
token: Literal::byte_string(&other.value()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&LitByteStr> for syn::LitByteStr {
|
||||||
|
fn from(other: &LitByteStr) -> Self {
|
||||||
|
let value = value::parse_lit_byte_str(&other.token.text);
|
||||||
|
Self::new(&value, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// LitByte
|
||||||
|
impl From<&syn::LitByte> for LitByte {
|
||||||
|
fn from(other: &syn::LitByte) -> Self {
|
||||||
|
Self {
|
||||||
|
token: Literal::u8_suffixed(other.value()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&LitByte> for syn::LitByte {
|
||||||
|
fn from(other: &LitByte) -> Self {
|
||||||
|
let value = value::parse_lit_byte(&other.token.text);
|
||||||
|
Self::new(value, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// LitChar
|
||||||
|
impl From<&syn::LitChar> for LitChar {
|
||||||
|
fn from(other: &syn::LitChar) -> Self {
|
||||||
|
Self {
|
||||||
|
token: Literal::character(other.value()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&LitChar> for syn::LitChar {
|
||||||
|
fn from(other: &LitChar) -> Self {
|
||||||
|
let value = value::parse_lit_char(&other.token.text);
|
||||||
|
Self::new(value, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// LitInt
|
||||||
|
impl From<&syn::LitInt> for LitInt {
|
||||||
|
fn from(other: &syn::LitInt) -> Self {
|
||||||
|
Self {
|
||||||
|
token: value::to_literal(&other.to_string()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&LitInt> for syn::LitInt {
|
||||||
|
fn from(other: &LitInt) -> Self {
|
||||||
|
Self::new(&other.token.text, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// LitFloat
|
||||||
|
impl From<&syn::LitFloat> for LitFloat {
|
||||||
|
fn from(other: &syn::LitFloat) -> Self {
|
||||||
|
Self {
|
||||||
|
token: value::to_literal(&other.to_string()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&LitFloat> for syn::LitFloat {
|
||||||
|
fn from(other: &LitFloat) -> Self {
|
||||||
|
Self::new(&other.token.text, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
19
syn-serde/src/mac.rs
Normal file
19
syn-serde/src/mac.rs
Normal file
|
|
@ -0,0 +1,19 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro invocation: `println!("{}", mac)`.
|
||||||
|
pub struct Macro {
|
||||||
|
pub(crate) path: Path,
|
||||||
|
pub(crate) delimiter: MacroDelimiter,
|
||||||
|
pub(crate) tokens: TokenStream,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A grouping token that surrounds a macro body: `m!(...)` or `m!{...}` or `m![...]`.
|
||||||
|
pub enum MacroDelimiter {
|
||||||
|
Paren,
|
||||||
|
Brace,
|
||||||
|
Bracket,
|
||||||
|
}
|
||||||
|
}
|
||||||
57
syn-serde/src/macros.rs
Normal file
57
syn-serde/src/macros.rs
Normal file
|
|
@ -0,0 +1,57 @@
|
||||||
|
macro_rules! ast_struct {
|
||||||
|
(
|
||||||
|
[$($attrs_pub:tt)*]
|
||||||
|
struct $name:ident $($rest:tt)*
|
||||||
|
) => {
|
||||||
|
#[derive(Debug, crate::Serialize, crate::Deserialize)]
|
||||||
|
$($attrs_pub)* struct $name $($rest)*
|
||||||
|
};
|
||||||
|
|
||||||
|
($($t:tt)*) => {
|
||||||
|
strip_attrs_pub!(ast_struct!($($t)*));
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! ast_enum {
|
||||||
|
(
|
||||||
|
[$($attrs_pub:tt)*]
|
||||||
|
enum $name:ident $($rest:tt)*
|
||||||
|
) => (
|
||||||
|
#[derive(Debug, crate::Serialize, crate::Deserialize)]
|
||||||
|
#[serde(rename_all = "snake_case")]
|
||||||
|
$($attrs_pub)* enum $name $($rest)*
|
||||||
|
);
|
||||||
|
|
||||||
|
($($t:tt)*) => {
|
||||||
|
strip_attrs_pub!(ast_enum!($($t)*));
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! strip_attrs_pub {
|
||||||
|
($mac:ident!($(#[$m:meta])* $pub:ident $($t:tt)*)) => {
|
||||||
|
check_keyword_matches!(pub $pub);
|
||||||
|
|
||||||
|
$mac!([$(#[$m])* $pub] $($t)*);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! check_keyword_matches {
|
||||||
|
(struct struct) => {};
|
||||||
|
(enum enum) => {};
|
||||||
|
(pub pub) => {};
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! syn_trait_impl {
|
||||||
|
($path:ident :: $ty:ident) => {
|
||||||
|
impl crate::private::Sealed for $path::$ty {}
|
||||||
|
impl crate::Syn for $path::$ty {
|
||||||
|
type Adapter = $ty;
|
||||||
|
fn to_adapter(&self) -> Self::Adapter {
|
||||||
|
Self::Adapter::from(self)
|
||||||
|
}
|
||||||
|
fn from_adapter(adapter: &Self::Adapter) -> Self {
|
||||||
|
Self::from(adapter)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
104
syn-serde/src/op.rs
Normal file
104
syn-serde/src/op.rs
Normal file
|
|
@ -0,0 +1,104 @@
|
||||||
|
ast_enum! {
|
||||||
|
/// A binary operator: `+`, `+=`, `&`.
|
||||||
|
pub enum BinOp {
|
||||||
|
/// The `+` operator (addition)
|
||||||
|
#[serde(rename = "+")]
|
||||||
|
Add,
|
||||||
|
/// The `-` operator (subtraction)
|
||||||
|
#[serde(rename = "-")]
|
||||||
|
Sub,
|
||||||
|
/// The `*` operator (multiplication)
|
||||||
|
#[serde(rename = "*")]
|
||||||
|
Mul,
|
||||||
|
/// The `/` operator (division)
|
||||||
|
#[serde(rename = "/")]
|
||||||
|
Div,
|
||||||
|
/// The `%` operator (modulus)
|
||||||
|
#[serde(rename = "%")]
|
||||||
|
Rem,
|
||||||
|
/// The `&&` operator (logical and)
|
||||||
|
#[serde(rename = "&&")]
|
||||||
|
And,
|
||||||
|
/// The `||` operator (logical or)
|
||||||
|
#[serde(rename = "||")]
|
||||||
|
Or,
|
||||||
|
/// The `^` operator (bitwise xor)
|
||||||
|
#[serde(rename = "^")]
|
||||||
|
BitXor,
|
||||||
|
/// The `&` operator (bitwise and)
|
||||||
|
#[serde(rename = "&")]
|
||||||
|
BitAnd,
|
||||||
|
/// The `|` operator (bitwise or)
|
||||||
|
#[serde(rename = "|")]
|
||||||
|
BitOr,
|
||||||
|
/// The `<<` operator (shift left)
|
||||||
|
#[serde(rename = "<<")]
|
||||||
|
Shl,
|
||||||
|
/// The `>>` operator (shift right)
|
||||||
|
#[serde(rename = ">>")]
|
||||||
|
Shr,
|
||||||
|
/// The `==` operator (equality)
|
||||||
|
#[serde(rename = "==")]
|
||||||
|
Eq,
|
||||||
|
/// The `<` operator (less than)
|
||||||
|
#[serde(rename = "<")]
|
||||||
|
Lt,
|
||||||
|
/// The `<=` operator (less than or equal to)
|
||||||
|
#[serde(rename = "<=")]
|
||||||
|
Le,
|
||||||
|
/// The `!=` operator (not equal to)
|
||||||
|
#[serde(rename = "!=")]
|
||||||
|
Ne,
|
||||||
|
/// The `>=` operator (greater than or equal to)
|
||||||
|
#[serde(rename = ">=")]
|
||||||
|
Ge,
|
||||||
|
/// The `>` operator (greater than)
|
||||||
|
#[serde(rename = ">")]
|
||||||
|
Gt,
|
||||||
|
/// The `+=` operator
|
||||||
|
#[serde(rename = "+=")]
|
||||||
|
AddEq,
|
||||||
|
/// The `-=` operator
|
||||||
|
#[serde(rename = "-=")]
|
||||||
|
SubEq,
|
||||||
|
/// The `*=` operator
|
||||||
|
#[serde(rename = "*=")]
|
||||||
|
MulEq,
|
||||||
|
/// The `/=` operator
|
||||||
|
#[serde(rename = "/=")]
|
||||||
|
DivEq,
|
||||||
|
/// The `%=` operator
|
||||||
|
#[serde(rename = "%=")]
|
||||||
|
RemEq,
|
||||||
|
/// The `^=` operator
|
||||||
|
#[serde(rename = "^=")]
|
||||||
|
BitXorEq,
|
||||||
|
/// The `&=` operator
|
||||||
|
#[serde(rename = "&=")]
|
||||||
|
BitAndEq,
|
||||||
|
/// The `|=` operator
|
||||||
|
#[serde(rename = "|=")]
|
||||||
|
BitOrEq,
|
||||||
|
/// The `<<=` operator
|
||||||
|
#[serde(rename = "<<=")]
|
||||||
|
ShlEq,
|
||||||
|
/// The `>>=` operator
|
||||||
|
#[serde(rename = ">>=")]
|
||||||
|
ShrEq,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A unary operator: `*`, `!`, `-`.
|
||||||
|
pub enum UnOp {
|
||||||
|
/// The `*` operator for dereferencing
|
||||||
|
#[serde(rename = "*")]
|
||||||
|
Deref,
|
||||||
|
/// The `!` operator for logical inversion
|
||||||
|
#[serde(rename = "!")]
|
||||||
|
Not,
|
||||||
|
/// The `-` operator for negation
|
||||||
|
#[serde(rename = "-")]
|
||||||
|
Neg,
|
||||||
|
}
|
||||||
|
}
|
||||||
250
syn-serde/src/pat.rs
Normal file
250
syn-serde/src/pat.rs
Normal file
|
|
@ -0,0 +1,250 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A pattern in a local binding, function signature, match expression, or
|
||||||
|
/// various other places.
|
||||||
|
pub enum Pat {
|
||||||
|
/// A box pattern: `box v`.
|
||||||
|
Box(PatBox),
|
||||||
|
|
||||||
|
/// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`.
|
||||||
|
Ident(PatIdent),
|
||||||
|
|
||||||
|
/// A literal pattern: `0`.
|
||||||
|
///
|
||||||
|
/// This holds an `Expr` rather than a `Lit` because negative numbers
|
||||||
|
/// are represented as an `Expr::Unary`.
|
||||||
|
Lit(PatLit),
|
||||||
|
|
||||||
|
/// A macro in pattern position.
|
||||||
|
Macro(PatMacro),
|
||||||
|
|
||||||
|
/// A pattern that matches any one of a set of cases.
|
||||||
|
Or(PatOr),
|
||||||
|
|
||||||
|
/// A path pattern like `Color::Red`, optionally qualified with a
|
||||||
|
/// self-type.
|
||||||
|
///
|
||||||
|
/// Unqualified path patterns can legally refer to variants, structs,
|
||||||
|
/// constants or associated constants. Qualified path patterns like
|
||||||
|
/// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
|
||||||
|
/// associated constants.
|
||||||
|
Path(PatPath),
|
||||||
|
|
||||||
|
/// A range pattern: `1..=2`.
|
||||||
|
Range(PatRange),
|
||||||
|
|
||||||
|
/// A reference pattern: `&mut var`.
|
||||||
|
Reference(PatReference),
|
||||||
|
|
||||||
|
/// The dots in a tuple or slice pattern: `[0, 1, ..]`
|
||||||
|
Rest(PatRest),
|
||||||
|
|
||||||
|
/// A dynamically sized slice pattern: `[a, b, ref i @ .., y, z]`.
|
||||||
|
Slice(PatSlice),
|
||||||
|
|
||||||
|
/// A struct or struct variant pattern: `Variant { x, y, .. }`.
|
||||||
|
Struct(PatStruct),
|
||||||
|
|
||||||
|
/// A tuple pattern: `(a, b)`.
|
||||||
|
Tuple(PatTuple),
|
||||||
|
|
||||||
|
/// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`.
|
||||||
|
TupleStruct(PatTupleStruct),
|
||||||
|
|
||||||
|
/// A type ascription pattern: `foo: f64`.
|
||||||
|
Type(PatType),
|
||||||
|
|
||||||
|
/// Tokens in pattern position not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
/// A pattern that matches any value: `_`.
|
||||||
|
#[serde(rename = "_")]
|
||||||
|
Wild(PatWild),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A box pattern: `box v`.
|
||||||
|
pub struct PatBox {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) pat: Box<Pat>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`.
|
||||||
|
pub struct PatIdent {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "ref")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) by_ref: bool,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) subpat: Option<Box<Pat>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A literal pattern: `0`.
|
||||||
|
///
|
||||||
|
/// This holds an `Expr` rather than a `Lit` because negative numbers
|
||||||
|
/// are represented as an `Expr::Unary`.
|
||||||
|
pub struct PatLit {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) expr: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro in pattern position.
|
||||||
|
pub struct PatMacro {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A pattern that matches any one of a set of cases.
|
||||||
|
pub struct PatOr {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) leading_vert: bool,
|
||||||
|
pub(crate) cases: Punctuated<Pat>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A path pattern like `Color::Red`, optionally qualified with a
|
||||||
|
/// self-type.
|
||||||
|
///
|
||||||
|
/// Unqualified path patterns can legally refer to variants, structs,
|
||||||
|
/// constants or associated constants. Qualified path patterns like
|
||||||
|
/// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
|
||||||
|
/// associated constants.
|
||||||
|
pub struct PatPath {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) qself: Option<QSelf>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) path: Path,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A range pattern: `1..=2`.
|
||||||
|
pub struct PatRange {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) lo: Box<Expr>,
|
||||||
|
pub(crate) limits: RangeLimits,
|
||||||
|
pub(crate) hi: Box<Expr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A reference pattern: `&mut var`.
|
||||||
|
pub struct PatReference {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) pat: Box<Pat>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// The dots in a tuple or slice pattern: `[0, 1, ..]`
|
||||||
|
pub struct PatRest {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A dynamically sized slice pattern: `[a, b, ref i @ .., y, z]`.
|
||||||
|
pub struct PatSlice {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) elems: Punctuated<Pat>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A struct or struct variant pattern: `Variant { x, y, .. }`.
|
||||||
|
pub struct PatStruct {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) path: Path,
|
||||||
|
pub(crate) fields: Punctuated<FieldPat>,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) dot2_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A tuple pattern: `(a, b)`.
|
||||||
|
pub struct PatTuple {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) elems: Punctuated<Pat>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`.
|
||||||
|
pub struct PatTupleStruct {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) path: Path,
|
||||||
|
pub(crate) pat: PatTuple,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A type ascription pattern: `foo: f64`.
|
||||||
|
pub struct PatType {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) pat: Box<Pat>,
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A pattern that matches any value: `_`.
|
||||||
|
pub struct PatWild {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// 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` but there is no colon token.
|
||||||
|
pub struct FieldPat {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) member: Member,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon_token: bool,
|
||||||
|
pub(crate) pat: Box<Pat>,
|
||||||
|
}
|
||||||
|
}
|
||||||
136
syn-serde/src/path.rs
Normal file
136
syn-serde/src/path.rs
Normal file
|
|
@ -0,0 +1,136 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A path at which a named item is exported: `std::collections::HashMap`.
|
||||||
|
pub struct Path {
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) leading_colon: bool,
|
||||||
|
pub(crate) segments: Punctuated<PathSegment>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A segment of a path together with any path arguments on that segment.
|
||||||
|
pub struct PathSegment {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
#[serde(default, skip_serializing_if = "PathArguments::is_none")]
|
||||||
|
pub(crate) arguments: PathArguments,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Angle bracketed or parenthesized arguments of a path segment.
|
||||||
|
///
|
||||||
|
/// ## 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 {
|
||||||
|
fn is_none(&self) -> bool {
|
||||||
|
match self {
|
||||||
|
PathArguments::None => true,
|
||||||
|
PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// An individual generic argument, like `'a`, `T`, or `Item = T`.
|
||||||
|
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),
|
||||||
|
/// An associated type bound: `Iterator<Item: Display>`.
|
||||||
|
Constraint(Constraint),
|
||||||
|
/// 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>`.
|
||||||
|
pub struct AngleBracketedGenericArguments {
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) colon2_token: bool,
|
||||||
|
pub(crate) args: Punctuated<GenericArgument>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A binding (equality constraint) on an associated type: `Item = u8`.
|
||||||
|
pub struct Binding {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An associated type bound: `Iterator<Item: Display>`.
|
||||||
|
pub struct Constraint {
|
||||||
|
pub(crate) ident: Ident,
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Arguments of a function path segment: the `(A, B) -> C` in `Fn(A,B) ->
|
||||||
|
/// C`.
|
||||||
|
pub struct ParenthesizedGenericArguments {
|
||||||
|
/// `(A, B)`
|
||||||
|
pub(crate) inputs: Punctuated<Type>,
|
||||||
|
/// `C`
|
||||||
|
#[serde(default)]
|
||||||
|
pub(crate) 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
|
||||||
|
/// ```
|
||||||
|
pub struct QSelf {
|
||||||
|
pub(crate) ty: Box<Type>,
|
||||||
|
pub(crate) position: usize,
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) as_token: bool,
|
||||||
|
}
|
||||||
|
}
|
||||||
39
syn-serde/src/stmt.rs
Normal file
39
syn-serde/src/stmt.rs
Normal file
|
|
@ -0,0 +1,39 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A braced block containing Rust statements.
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Block {
|
||||||
|
/// Statements in a block
|
||||||
|
pub(crate) stmts: Vec<Stmt>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A statement, usually ending in a semicolon.
|
||||||
|
pub enum Stmt {
|
||||||
|
/// A local (let) binding.
|
||||||
|
#[serde(rename = "let")]
|
||||||
|
Local(Local),
|
||||||
|
|
||||||
|
/// An item definition.
|
||||||
|
Item(Item),
|
||||||
|
|
||||||
|
/// Expr without trailing semicolon.
|
||||||
|
Expr(Expr),
|
||||||
|
|
||||||
|
/// Expression with trailing semicolon.
|
||||||
|
Semi(Expr),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A local `let` binding: `let x: u64 = s.parse()?`.
|
||||||
|
pub struct Local {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
pub(crate) pat: Pat,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) init: Option<Box<Expr>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
345
syn-serde/src/token_stream.rs
Normal file
345
syn-serde/src/token_stream.rs
Normal file
|
|
@ -0,0 +1,345 @@
|
||||||
|
use super::*;
|
||||||
|
use std::fmt;
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An abstract stream of tokens, or more concretely a sequence of token trees.
|
||||||
|
///
|
||||||
|
/// This type provides interfaces for iterating over token trees and for
|
||||||
|
/// collecting token trees into one stream.
|
||||||
|
#[derive(Clone, Default)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct TokenStream {
|
||||||
|
inner: Vec<TokenTree>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TokenStream {
|
||||||
|
fn _new(inner: Vec<TokenTree>) -> Self {
|
||||||
|
Self { inner }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn is_empty(&self) -> bool {
|
||||||
|
self.inner.is_empty()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`).
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum TokenTree {
|
||||||
|
/// A token stream surrounded by bracket delimiters.
|
||||||
|
Group(Group),
|
||||||
|
/// An identifier.
|
||||||
|
Ident(Ident),
|
||||||
|
/// A single punctuation character (`+`, `,`, `$`, etc.).
|
||||||
|
Punct(Punct),
|
||||||
|
/// A literal character (`'a'`), string (`"hello"`), number (`2.3`), etc.
|
||||||
|
#[serde(rename = "lit")]
|
||||||
|
Literal(Literal),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A delimited token stream.
|
||||||
|
///
|
||||||
|
/// A `Group` internally contains a `TokenStream` which is surrounded by
|
||||||
|
/// `Delimiter`s.
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Group {
|
||||||
|
delimiter: Delimiter,
|
||||||
|
stream: TokenStream,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Describes how a sequence of token trees is delimited.
|
||||||
|
#[derive(Clone, Copy)]
|
||||||
|
pub enum Delimiter {
|
||||||
|
/// `( ... )`
|
||||||
|
Parenthesis,
|
||||||
|
/// `{ ... }`
|
||||||
|
Brace,
|
||||||
|
/// `[ ... ]`
|
||||||
|
Bracket,
|
||||||
|
/// `Ø ... Ø`
|
||||||
|
///
|
||||||
|
/// An implicit delimiter, that may, for example, appear around tokens
|
||||||
|
/// coming from a "macro variable" `$var`. It is important to preserve
|
||||||
|
/// operator priorities in cases like `$var * 3` where `$var` is `1 + 2`.
|
||||||
|
/// Implicit delimiters may not survive roundtrip of a token stream through
|
||||||
|
/// a string.
|
||||||
|
None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An `Punct` is an single punctuation character like `+`, `-` or `#`.
|
||||||
|
///
|
||||||
|
/// Multicharacter operators like `+=` are represented as two instances of
|
||||||
|
/// `Punct` with different forms of `Spacing` returned.
|
||||||
|
#[derive(Clone, Copy)]
|
||||||
|
pub struct Punct {
|
||||||
|
op: char,
|
||||||
|
spacing: Spacing,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// Whether an `Punct` is followed immediately by another `Punct` or followed by
|
||||||
|
/// another token or whitespace.
|
||||||
|
#[derive(Clone, Copy)]
|
||||||
|
pub enum Spacing {
|
||||||
|
/// E.g. `+` is `Alone` in `+ =`, `+ident` or `+()`.
|
||||||
|
Alone,
|
||||||
|
/// E.g. `+` is `Joint` in `+=` or `'#`.
|
||||||
|
///
|
||||||
|
/// Additionally, single quote `'` can join with identifiers to form
|
||||||
|
/// lifetimes `'ident`.
|
||||||
|
Joint,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A word of Rust code, which may be a keyword or legal variable name.
|
||||||
|
///
|
||||||
|
/// An identifier consists of at least one Unicode code point, the first of
|
||||||
|
/// which has the XID_Start property and the rest of which have the XID_Continue
|
||||||
|
/// property.
|
||||||
|
///
|
||||||
|
/// - The empty string is not an identifier. Use `Option<Ident>`.
|
||||||
|
/// - A lifetime is not an identifier. Use `syn::Lifetime` instead.
|
||||||
|
#[derive(Clone, Eq, PartialEq)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Ident {
|
||||||
|
inner: String,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A literal string (`"hello"`), byte string (`b"hello"`), character (`'a'`),
|
||||||
|
/// byte character (`b'a'`), an integer or floating point number with or without
|
||||||
|
/// a suffix (`1`, `1u8`, `2.3`, `2.3f32`).
|
||||||
|
///
|
||||||
|
/// Boolean literals like `true` and `false` do not belong here, they are
|
||||||
|
/// `Ident`s.
|
||||||
|
#[derive(Clone)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Literal {
|
||||||
|
pub(crate) text: String,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Literal {
|
||||||
|
fn _new(text: String) -> Self {
|
||||||
|
Self { text }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn u8_suffixed(n: u8) -> Self {
|
||||||
|
Self::_new(format!(concat!("{}", stringify!(u8)), n))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn string(t: &str) -> Self {
|
||||||
|
let mut s = t.chars().flat_map(char::escape_default).collect::<String>();
|
||||||
|
s.push('"');
|
||||||
|
s.insert(0, '"');
|
||||||
|
Self::_new(s)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn character(t: char) -> Self {
|
||||||
|
Self::_new(format!("'{}'", t.escape_default().collect::<String>()))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(clippy::match_overlapping_arm)]
|
||||||
|
pub(crate) fn byte_string(bytes: &[u8]) -> Self {
|
||||||
|
let mut escaped = "b\"".to_string();
|
||||||
|
for b in bytes {
|
||||||
|
match *b {
|
||||||
|
b'\0' => escaped.push_str(r"\0"),
|
||||||
|
b'\t' => escaped.push_str(r"\t"),
|
||||||
|
b'\n' => escaped.push_str(r"\n"),
|
||||||
|
b'\r' => escaped.push_str(r"\r"),
|
||||||
|
b'"' => escaped.push_str("\\\""),
|
||||||
|
b'\\' => escaped.push_str("\\\\"),
|
||||||
|
b'\x20'..=b'\x7E' => escaped.push(*b as char),
|
||||||
|
_ => escaped.push_str(&format!("\\x{:02X}", b)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
escaped.push('"');
|
||||||
|
Self::_new(escaped)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO: when release the next minor version, remove this.
|
||||||
|
impl fmt::Display for Literal {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
self.text.fmt(f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// TokenStream
|
||||||
|
syn_trait_impl!(proc_macro2::TokenStream);
|
||||||
|
impl From<&proc_macro2::TokenStream> for TokenStream {
|
||||||
|
fn from(other: &proc_macro2::TokenStream) -> Self {
|
||||||
|
Self::_new(
|
||||||
|
other
|
||||||
|
.clone()
|
||||||
|
.into_iter()
|
||||||
|
.map::<TokenTree, _>(|x| x.ref_into())
|
||||||
|
.collect(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&TokenStream> for proc_macro2::TokenStream {
|
||||||
|
fn from(other: &TokenStream) -> Self {
|
||||||
|
other
|
||||||
|
.inner
|
||||||
|
.iter()
|
||||||
|
.map::<proc_macro2::TokenTree, _>(Into::into)
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TokenTree
|
||||||
|
syn_trait_impl!(proc_macro2::TokenTree);
|
||||||
|
impl From<&proc_macro2::TokenTree> for TokenTree {
|
||||||
|
fn from(other: &proc_macro2::TokenTree) -> Self {
|
||||||
|
use super::TokenTree::*;
|
||||||
|
use proc_macro2::TokenTree;
|
||||||
|
match other {
|
||||||
|
TokenTree::Group(t) => Group(t.into()),
|
||||||
|
TokenTree::Ident(t) => Ident(t.into()),
|
||||||
|
TokenTree::Punct(t) => Punct(t.into()),
|
||||||
|
TokenTree::Literal(t) => Literal(t.into()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&TokenTree> for proc_macro2::TokenTree {
|
||||||
|
fn from(other: &TokenTree) -> Self {
|
||||||
|
use proc_macro2::TokenTree::*;
|
||||||
|
match other {
|
||||||
|
TokenTree::Group(t) => Group(t.into()),
|
||||||
|
TokenTree::Ident(t) => Ident(t.into()),
|
||||||
|
TokenTree::Punct(t) => Punct(t.into()),
|
||||||
|
TokenTree::Literal(t) => Literal(t.into()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Group
|
||||||
|
syn_trait_impl!(proc_macro2::Group);
|
||||||
|
impl From<&proc_macro2::Group> for Group {
|
||||||
|
fn from(other: &proc_macro2::Group) -> Self {
|
||||||
|
Self {
|
||||||
|
delimiter: other.delimiter().ref_into(),
|
||||||
|
stream: other.stream().ref_into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Group> for proc_macro2::Group {
|
||||||
|
fn from(other: &Group) -> Self {
|
||||||
|
Self::new(other.delimiter.ref_into(), other.stream.ref_into())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Delimiter
|
||||||
|
syn_trait_impl!(proc_macro2::Delimiter);
|
||||||
|
impl From<&proc_macro2::Delimiter> for Delimiter {
|
||||||
|
fn from(other: &proc_macro2::Delimiter) -> Self {
|
||||||
|
use super::Delimiter::*;
|
||||||
|
use proc_macro2::Delimiter;
|
||||||
|
match other {
|
||||||
|
Delimiter::Parenthesis => Parenthesis,
|
||||||
|
Delimiter::Brace => Brace,
|
||||||
|
Delimiter::Bracket => Bracket,
|
||||||
|
Delimiter::None => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Delimiter> for proc_macro2::Delimiter {
|
||||||
|
fn from(other: &Delimiter) -> Self {
|
||||||
|
use proc_macro2::Delimiter::*;
|
||||||
|
match other {
|
||||||
|
Delimiter::Parenthesis => Parenthesis,
|
||||||
|
Delimiter::Brace => Brace,
|
||||||
|
Delimiter::Bracket => Bracket,
|
||||||
|
Delimiter::None => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ident
|
||||||
|
syn_trait_impl!(proc_macro2::Ident);
|
||||||
|
impl From<&proc_macro2::Ident> for Ident {
|
||||||
|
fn from(other: &proc_macro2::Ident) -> Self {
|
||||||
|
Self {
|
||||||
|
inner: other.to_string(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Ident> for proc_macro2::Ident {
|
||||||
|
fn from(other: &Ident) -> Self {
|
||||||
|
Self::new(&other.inner, Span::call_site())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Punct
|
||||||
|
syn_trait_impl!(proc_macro2::Punct);
|
||||||
|
impl From<&proc_macro2::Punct> for Punct {
|
||||||
|
fn from(other: &proc_macro2::Punct) -> Self {
|
||||||
|
Self {
|
||||||
|
op: other.as_char(),
|
||||||
|
spacing: other.spacing().ref_into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Punct> for proc_macro2::Punct {
|
||||||
|
fn from(other: &Punct) -> Self {
|
||||||
|
Self::new(other.op, other.spacing.ref_into())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Spacing
|
||||||
|
syn_trait_impl!(proc_macro2::Spacing);
|
||||||
|
impl From<&proc_macro2::Spacing> for Spacing {
|
||||||
|
fn from(other: &proc_macro2::Spacing) -> Self {
|
||||||
|
use super::Spacing::*;
|
||||||
|
use proc_macro2::Spacing;
|
||||||
|
match other {
|
||||||
|
Spacing::Alone => Alone,
|
||||||
|
Spacing::Joint => Joint,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Spacing> for proc_macro2::Spacing {
|
||||||
|
fn from(other: &Spacing) -> Self {
|
||||||
|
use proc_macro2::Spacing::*;
|
||||||
|
match other {
|
||||||
|
Spacing::Alone => Alone,
|
||||||
|
Spacing::Joint => Joint,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Literal
|
||||||
|
syn_trait_impl!(proc_macro2::Literal);
|
||||||
|
impl From<&proc_macro2::Literal> for Literal {
|
||||||
|
fn from(other: &proc_macro2::Literal) -> Self {
|
||||||
|
Self {
|
||||||
|
text: other.to_string(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Literal> for proc_macro2::Literal {
|
||||||
|
fn from(other: &Literal) -> Self {
|
||||||
|
use proc_macro2::*;
|
||||||
|
let stream = other.text.parse::<TokenStream>().unwrap();
|
||||||
|
match stream.into_iter().next().unwrap() {
|
||||||
|
TokenTree::Literal(l) => l,
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
291
syn-serde/src/ty.rs
Normal file
291
syn-serde/src/ty.rs
Normal file
|
|
@ -0,0 +1,291 @@
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
ast_enum! {
|
||||||
|
/// The possible types that a Rust value could have.
|
||||||
|
pub enum Type {
|
||||||
|
/// A fixed size array type: `[T; n]`.
|
||||||
|
Array(TypeArray),
|
||||||
|
|
||||||
|
/// A bare function type: `fn(usize) -> bool`.
|
||||||
|
BareFn(TypeBareFn),
|
||||||
|
|
||||||
|
/// A type contained within invisible delimiters.
|
||||||
|
Group(TypeGroup),
|
||||||
|
|
||||||
|
/// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
|
||||||
|
/// a lifetime.
|
||||||
|
ImplTrait(TypeImplTrait),
|
||||||
|
|
||||||
|
/// Indication that a type should be inferred by the compiler: `_`.
|
||||||
|
#[serde(rename = "_")]
|
||||||
|
Infer,
|
||||||
|
|
||||||
|
/// A macro in the type position.
|
||||||
|
Macro(TypeMacro),
|
||||||
|
|
||||||
|
/// The never type: `!`.
|
||||||
|
#[serde(rename = "!")]
|
||||||
|
Never,
|
||||||
|
|
||||||
|
/// A parenthesized type equivalent to the inner type.
|
||||||
|
Paren(TypeParen),
|
||||||
|
|
||||||
|
/// A path like `std::slice::Iter`, optionally qualified with a
|
||||||
|
/// self-type as in `<Vec<T> as SomeTrait>::Associated`.
|
||||||
|
Path(TypePath),
|
||||||
|
|
||||||
|
/// A raw pointer type: `*const T` or `*mut T`.
|
||||||
|
Ptr(TypePtr),
|
||||||
|
|
||||||
|
/// A reference type: `&'a T` or `&'a mut T`.
|
||||||
|
Reference(TypeReference),
|
||||||
|
|
||||||
|
/// A dynamically sized slice type: `[T]`.
|
||||||
|
Slice(TypeSlice),
|
||||||
|
|
||||||
|
/// A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a
|
||||||
|
/// trait or a lifetime.
|
||||||
|
TraitObject(TypeTraitObject),
|
||||||
|
|
||||||
|
/// A tuple type: `(A, B, C, String)`.
|
||||||
|
Tuple(TypeTuple),
|
||||||
|
|
||||||
|
/// Tokens in type position not interpreted by Syn.
|
||||||
|
Verbatim(TokenStream),
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
__Nonexhaustive,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A fixed size array type: `[T; n]`.
|
||||||
|
pub struct TypeArray {
|
||||||
|
pub(crate) elem: Box<Type>,
|
||||||
|
pub(crate) len: Expr,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A bare function type: `fn(usize) -> bool`.
|
||||||
|
pub struct TypeBareFn {
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) lifetimes: Option<BoundLifetimes>,
|
||||||
|
#[serde(rename = "unsafe")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) unsafety: bool,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) abi: Option<Abi>,
|
||||||
|
pub(crate) inputs: Punctuated<BareFnArg>,
|
||||||
|
pub(crate) variadic: Option<Variadic>,
|
||||||
|
pub(crate) output: ReturnType,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A type contained within invisible delimiters.
|
||||||
|
pub struct TypeGroup {
|
||||||
|
pub(crate) elem: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
|
||||||
|
/// a lifetime.
|
||||||
|
pub struct TypeImplTrait {
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A macro in the type position.
|
||||||
|
pub struct TypeMacro {
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) mac: Macro,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A parenthesized type equivalent to the inner type.
|
||||||
|
pub struct TypeParen {
|
||||||
|
pub(crate) elem: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A path like `std::slice::Iter`, optionally qualified with a
|
||||||
|
/// self-type as in `<Vec<T> as SomeTrait>::Associated`.
|
||||||
|
pub struct TypePath {
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) qself: Option<QSelf>,
|
||||||
|
#[serde(flatten)]
|
||||||
|
pub(crate) path: Path,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A raw pointer type: `*const T` or `*mut T`.
|
||||||
|
pub struct TypePtr {
|
||||||
|
#[serde(rename = "const")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) const_token: bool,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) elem: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A reference type: `&'a T` or `&'a mut T`.
|
||||||
|
pub struct TypeReference {
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) lifetime: Option<Lifetime>,
|
||||||
|
#[serde(rename = "mut")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) mutability: bool,
|
||||||
|
pub(crate) elem: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A dynamically sized slice type: `[T]`.
|
||||||
|
pub struct TypeSlice {
|
||||||
|
pub(crate) elem: Box<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a
|
||||||
|
/// trait or a lifetime.
|
||||||
|
pub struct TypeTraitObject {
|
||||||
|
#[serde(rename = "dyn")]
|
||||||
|
#[serde(default, skip_serializing_if = "not")]
|
||||||
|
pub(crate) dyn_token: bool,
|
||||||
|
pub(crate) bounds: Punctuated<TypeParamBound>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// A tuple type: `(A, B, C, String)`.
|
||||||
|
pub struct TypeTuple {
|
||||||
|
pub(crate) elems: Punctuated<Type>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// The binary interface of a function: `extern "C"`.
|
||||||
|
pub struct Abi {
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) name: Option<LitStr>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// An argument in a function type: the `usize` in `fn(usize) -> bool`.
|
||||||
|
pub struct BareFnArg {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub(crate) name: Option<Ident>,
|
||||||
|
pub(crate) ty: Type,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// The variadic argument of a foreign function.
|
||||||
|
pub struct Variadic {
|
||||||
|
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||||
|
pub(crate) attrs: Vec<Attribute>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ast_struct! {
|
||||||
|
/// Return type of a function signature.
|
||||||
|
#[derive(Default)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct ReturnType {
|
||||||
|
ty: Option<Box<Type>>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod convert {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
// Type
|
||||||
|
syn_trait_impl!(syn::Type);
|
||||||
|
impl From<&syn::Type> for Type {
|
||||||
|
fn from(other: &syn::Type) -> Self {
|
||||||
|
use super::Type::*;
|
||||||
|
use syn::Type;
|
||||||
|
match other {
|
||||||
|
Type::Slice(x) => Slice(x.into()),
|
||||||
|
Type::Array(x) => Array(x.into()),
|
||||||
|
Type::Ptr(x) => Ptr(x.into()),
|
||||||
|
Type::Reference(x) => Reference(x.into()),
|
||||||
|
Type::BareFn(x) => BareFn(x.into()),
|
||||||
|
Type::Never(_) => Never,
|
||||||
|
Type::Tuple(x) => Tuple(x.into()),
|
||||||
|
Type::Path(x) => Path(x.into()),
|
||||||
|
Type::TraitObject(x) => TraitObject(x.into()),
|
||||||
|
Type::ImplTrait(x) => ImplTrait(x.into()),
|
||||||
|
Type::Paren(x) => Paren(x.into()),
|
||||||
|
Type::Group(x) => Group(x.into()),
|
||||||
|
Type::Infer(_) => Infer,
|
||||||
|
Type::Macro(x) => Macro(x.into()),
|
||||||
|
Type::Verbatim(x) => Verbatim(x.into()),
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&Type> for syn::Type {
|
||||||
|
fn from(other: &Type) -> Self {
|
||||||
|
use syn::Type::*;
|
||||||
|
match other {
|
||||||
|
Type::Slice(x) => Slice(x.into()),
|
||||||
|
Type::Array(x) => Array(x.into()),
|
||||||
|
Type::Ptr(x) => Ptr(x.into()),
|
||||||
|
Type::Reference(x) => Reference(x.into()),
|
||||||
|
Type::BareFn(x) => BareFn(x.into()),
|
||||||
|
Type::Never => Never(syn::TypeNever {
|
||||||
|
bang_token: default(),
|
||||||
|
}),
|
||||||
|
Type::Tuple(x) => Tuple(x.into()),
|
||||||
|
Type::Path(x) => Path(x.into()),
|
||||||
|
Type::TraitObject(x) => TraitObject(x.into()),
|
||||||
|
Type::ImplTrait(x) => ImplTrait(x.into()),
|
||||||
|
Type::Paren(x) => Paren(x.into()),
|
||||||
|
Type::Group(x) => Group(x.into()),
|
||||||
|
Type::Infer => Infer(syn::TypeInfer {
|
||||||
|
underscore_token: default(),
|
||||||
|
}),
|
||||||
|
Type::Macro(x) => Macro(x.into()),
|
||||||
|
Type::Verbatim(x) => Verbatim(x.into()),
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ReturnType
|
||||||
|
syn_trait_impl!(syn::ReturnType);
|
||||||
|
impl From<&syn::ReturnType> for ReturnType {
|
||||||
|
fn from(other: &syn::ReturnType) -> Self {
|
||||||
|
use syn::ReturnType;
|
||||||
|
match other {
|
||||||
|
ReturnType::Default => Self { ty: None },
|
||||||
|
ReturnType::Type(_, x) => Self {
|
||||||
|
ty: Some(x.map_into()),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<&ReturnType> for syn::ReturnType {
|
||||||
|
fn from(other: &ReturnType) -> Self {
|
||||||
|
use syn::ReturnType;
|
||||||
|
match &other.ty {
|
||||||
|
None => ReturnType::Default,
|
||||||
|
Some(x) => ReturnType::Type(default(), x.map_into()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
5616
syn-serde/syn.json
Normal file
5616
syn-serde/syn.json
Normal file
File diff suppressed because it is too large
Load diff
740
syn-serde/tests/test_item.rs
Normal file
740
syn-serde/tests/test_item.rs
Normal file
|
|
@ -0,0 +1,740 @@
|
||||||
|
use syn::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_unit() {
|
||||||
|
let raw = "struct Unit;";
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"ident": "Unit",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let ser: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let ser = Item::from(&ser);
|
||||||
|
assert_eq!(ser, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_struct() {
|
||||||
|
let raw = "
|
||||||
|
#[derive(Debug, Clone)]
|
||||||
|
pub struct Item {
|
||||||
|
pub ident: Ident,
|
||||||
|
pub attrs: Vec<Attribute>
|
||||||
|
}
|
||||||
|
";
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"attrs": [
|
||||||
|
{
|
||||||
|
"style": "outer",
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "derive"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"group": {
|
||||||
|
"delimiter": "parenthesis",
|
||||||
|
"stream": [
|
||||||
|
{
|
||||||
|
"ident": "Debug"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": ",",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "Clone"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"vis": "pub",
|
||||||
|
"ident": "Item",
|
||||||
|
"fields": {
|
||||||
|
"named": [
|
||||||
|
{
|
||||||
|
"vis": "pub",
|
||||||
|
"ident": "ident",
|
||||||
|
"colon_token": true,
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Ident"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"vis": "pub",
|
||||||
|
"ident": "attrs",
|
||||||
|
"colon_token": true,
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Vec",
|
||||||
|
"arguments": {
|
||||||
|
"angle_bracketed": {
|
||||||
|
"args": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "Attribute"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_union() {
|
||||||
|
let raw = "
|
||||||
|
union MaybeUninit<T> {
|
||||||
|
uninit: (),
|
||||||
|
value: T
|
||||||
|
}
|
||||||
|
";
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"union": {
|
||||||
|
"ident": "MaybeUninit",
|
||||||
|
"generics": {
|
||||||
|
"params": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"ident": "T"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"fields": [
|
||||||
|
{
|
||||||
|
"ident": "uninit",
|
||||||
|
"colon_token": true,
|
||||||
|
"ty": {
|
||||||
|
"tuple": {
|
||||||
|
"elems": []
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "value",
|
||||||
|
"colon_token": true,
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "T"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_enum() {
|
||||||
|
let raw = r#"
|
||||||
|
/// See the std::result module documentation for details.
|
||||||
|
#[must_use]
|
||||||
|
pub enum Result<T, E> {
|
||||||
|
Ok(T),
|
||||||
|
Err(E),
|
||||||
|
Surprise = 0isize,
|
||||||
|
|
||||||
|
// Smuggling data into a proc_macro_derive,
|
||||||
|
// in the style of https://github.com/dtolnay/proc-macro-hack
|
||||||
|
ProcMacroHack = (0, "data").0
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"enum": {
|
||||||
|
"attrs": [
|
||||||
|
{
|
||||||
|
"style": "outer",
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "doc"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": "=",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"lit": "\" See the std::result module documentation for details.\""
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"style": "outer",
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "must_use"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"vis": "pub",
|
||||||
|
"ident": "Result",
|
||||||
|
"generics": {
|
||||||
|
"params": [
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"ident": "T"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"type": {
|
||||||
|
"ident": "E"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"variants": [
|
||||||
|
{
|
||||||
|
"ident": "Ok",
|
||||||
|
"fields": {
|
||||||
|
"unnamed": [
|
||||||
|
{
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "T"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "Err",
|
||||||
|
"fields": {
|
||||||
|
"unnamed": [
|
||||||
|
{
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "E"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "Surprise",
|
||||||
|
"fields": "unit",
|
||||||
|
"discriminant": {
|
||||||
|
"lit": {
|
||||||
|
"int": "0isize"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "ProcMacroHack",
|
||||||
|
"fields": "unit",
|
||||||
|
"discriminant": {
|
||||||
|
"field": {
|
||||||
|
"base": {
|
||||||
|
"tuple": {
|
||||||
|
"elems": [
|
||||||
|
{
|
||||||
|
"lit": {
|
||||||
|
"int": "0"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"lit": {
|
||||||
|
"str": "\"data\""
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"index": 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_attr_with_path() {
|
||||||
|
let raw = r#"
|
||||||
|
#[::attr_args::identity
|
||||||
|
fn main() { assert_eq!(foo(), "Hello, world!"); }]
|
||||||
|
struct Dummy;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"attrs": [
|
||||||
|
{
|
||||||
|
"style": "outer",
|
||||||
|
"path": {
|
||||||
|
"leading_colon": true,
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "attr_args"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "identity"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"ident": "fn"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "main"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"group": {
|
||||||
|
"delimiter": "parenthesis",
|
||||||
|
"stream": []
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"group": {
|
||||||
|
"delimiter": "brace",
|
||||||
|
"stream": [
|
||||||
|
{
|
||||||
|
"ident": "assert_eq"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": "!",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"group": {
|
||||||
|
"delimiter": "parenthesis",
|
||||||
|
"stream": [
|
||||||
|
{
|
||||||
|
"ident": "foo"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"group": {
|
||||||
|
"delimiter": "parenthesis",
|
||||||
|
"stream": []
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": ",",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"lit": "\"Hello, world!\""
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": ";",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"ident": "Dummy",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_attr_with_non_mod_style_path() {
|
||||||
|
let raw = r#"
|
||||||
|
#[inert <T>]
|
||||||
|
struct S;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"attrs": [
|
||||||
|
{
|
||||||
|
"style": "outer",
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "inert"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
"tokens": [
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": "<",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "T"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"punct": {
|
||||||
|
"op": ">",
|
||||||
|
"spacing": "alone"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"ident": "S",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_attr_with_mod_style_path_with_self() {
|
||||||
|
let raw = r#"
|
||||||
|
#[foo::self]
|
||||||
|
struct S;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"attrs": [
|
||||||
|
{
|
||||||
|
"style": "outer",
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "foo"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "self"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"ident": "S",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_pub_restricted() {
|
||||||
|
// Taken from tests/rust/src/test/ui/resolve/auxiliary/privacy-struct-ctor.rs
|
||||||
|
let raw = r#"
|
||||||
|
pub(in m) struct Z(pub(in m::n) u8);
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"vis": {
|
||||||
|
"restricted": {
|
||||||
|
"in_token": true,
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "m"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"ident": "Z",
|
||||||
|
"fields": {
|
||||||
|
"unnamed": [
|
||||||
|
{
|
||||||
|
"vis": {
|
||||||
|
"restricted": {
|
||||||
|
"in_token": true,
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "m"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "n"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "u8"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_vis_crate() {
|
||||||
|
let raw = r#"
|
||||||
|
crate struct S;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"vis": "crate",
|
||||||
|
"ident": "S",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_pub_restricted_crate() {
|
||||||
|
let raw = r#"
|
||||||
|
pub(crate) struct S;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"vis": {
|
||||||
|
"restricted": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "crate"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"ident": "S",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_pub_restricted_super() {
|
||||||
|
let raw = r#"
|
||||||
|
pub(super) struct S;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"vis": {
|
||||||
|
"restricted": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "super"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"ident": "S",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_pub_restricted_in_super() {
|
||||||
|
let raw = r#"
|
||||||
|
pub(in super) struct S;
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"vis": {
|
||||||
|
"restricted": {
|
||||||
|
"in_token": true,
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "super"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"ident": "S",
|
||||||
|
"fields": "unit"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_ambiguous_crate() {
|
||||||
|
// The field type is `(crate::X)` not `crate (::X)`.
|
||||||
|
let raw = "struct S(crate::X);";
|
||||||
|
|
||||||
|
let json = r#"
|
||||||
|
{
|
||||||
|
"struct": {
|
||||||
|
"ident": "S",
|
||||||
|
"fields": {
|
||||||
|
"unnamed": [
|
||||||
|
{
|
||||||
|
"ty": {
|
||||||
|
"path": {
|
||||||
|
"segments": [
|
||||||
|
{
|
||||||
|
"ident": "crate"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"ident": "X"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#;
|
||||||
|
|
||||||
|
let actual = syn::parse_str(raw).unwrap();
|
||||||
|
let json: syn_serde::Item = serde_json::from_str(json).unwrap();
|
||||||
|
let json = Item::from(&json);
|
||||||
|
assert_eq!(json, actual);
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue