Import Upstream version 0.2.83
This commit is contained in:
su-fang
commit
69d701d869
|
|
@ -0,0 +1,49 @@
|
||||||
|
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||||
|
#
|
||||||
|
# When uploading crates to the registry Cargo will automatically
|
||||||
|
# "normalize" Cargo.toml files for maximal compatibility
|
||||||
|
# with all versions of Cargo and also rewrite `path` dependencies
|
||||||
|
# to registry (e.g., crates.io) dependencies.
|
||||||
|
#
|
||||||
|
# If you are reading this file be aware that the original Cargo.toml
|
||||||
|
# will likely look very different (and much more reasonable).
|
||||||
|
# See Cargo.toml.orig for the original contents.
|
||||||
|
|
||||||
|
[package]
|
||||||
|
edition = "2018"
|
||||||
|
name = "wasm-bindgen-backend"
|
||||||
|
version = "0.2.83"
|
||||||
|
authors = ["The wasm-bindgen Developers"]
|
||||||
|
description = """
|
||||||
|
Backend code generation of the wasm-bindgen tool
|
||||||
|
"""
|
||||||
|
homepage = "https://rustwasm.github.io/wasm-bindgen/"
|
||||||
|
documentation = "https://docs.rs/wasm-bindgen-backend"
|
||||||
|
license = "MIT/Apache-2.0"
|
||||||
|
repository = "https://github.com/rustwasm/wasm-bindgen/tree/master/crates/backend"
|
||||||
|
|
||||||
|
[dependencies.bumpalo]
|
||||||
|
version = "3.0.0"
|
||||||
|
|
||||||
|
[dependencies.log]
|
||||||
|
version = "0.4"
|
||||||
|
|
||||||
|
[dependencies.once_cell]
|
||||||
|
version = "1.12"
|
||||||
|
|
||||||
|
[dependencies.proc-macro2]
|
||||||
|
version = "1.0"
|
||||||
|
|
||||||
|
[dependencies.quote]
|
||||||
|
version = "1.0"
|
||||||
|
|
||||||
|
[dependencies.syn]
|
||||||
|
version = "1.0"
|
||||||
|
features = ["full"]
|
||||||
|
|
||||||
|
[dependencies.wasm-bindgen-shared]
|
||||||
|
version = "=0.2.83"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
extra-traits = ["syn/extra-traits"]
|
||||||
|
spans = []
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
[package]
|
||||||
|
name = "wasm-bindgen-backend"
|
||||||
|
version = "0.2.83"
|
||||||
|
authors = ["The wasm-bindgen Developers"]
|
||||||
|
license = "MIT/Apache-2.0"
|
||||||
|
repository = "https://github.com/rustwasm/wasm-bindgen/tree/master/crates/backend"
|
||||||
|
homepage = "https://rustwasm.github.io/wasm-bindgen/"
|
||||||
|
documentation = "https://docs.rs/wasm-bindgen-backend"
|
||||||
|
description = """
|
||||||
|
Backend code generation of the wasm-bindgen tool
|
||||||
|
"""
|
||||||
|
edition = "2018"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
spans = []
|
||||||
|
extra-traits = ["syn/extra-traits"]
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
bumpalo = "3.0.0"
|
||||||
|
log = "0.4"
|
||||||
|
once_cell = "1.12"
|
||||||
|
proc-macro2 = "1.0"
|
||||||
|
quote = '1.0'
|
||||||
|
syn = { version = '1.0', features = ['full'] }
|
||||||
|
wasm-bindgen-shared = { path = "../shared", version = "=0.2.83" }
|
||||||
|
|
@ -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.
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
Copyright (c) 2014 Alex Crichton
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any
|
||||||
|
person obtaining a copy of this software and associated
|
||||||
|
documentation files (the "Software"), to deal in the
|
||||||
|
Software without restriction, including without
|
||||||
|
limitation the rights to use, copy, modify, merge,
|
||||||
|
publish, distribute, sublicense, and/or sell copies of
|
||||||
|
the Software, and to permit persons to whom the Software
|
||||||
|
is furnished to do so, subject to the following
|
||||||
|
conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice
|
||||||
|
shall be included in all copies or substantial portions
|
||||||
|
of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||||
|
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||||
|
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||||
|
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||||
|
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||||
|
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||||
|
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||||
|
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
DEALINGS IN THE SOFTWARE.
|
||||||
|
|
@ -0,0 +1,453 @@
|
||||||
|
//! A representation of the Abstract Syntax Tree of a Rust program,
|
||||||
|
//! with all the added metadata necessary to generate WASM bindings
|
||||||
|
//! for it.
|
||||||
|
|
||||||
|
use crate::Diagnostic;
|
||||||
|
use proc_macro2::{Ident, Span};
|
||||||
|
use std::hash::{Hash, Hasher};
|
||||||
|
use wasm_bindgen_shared as shared;
|
||||||
|
|
||||||
|
/// An abstract syntax tree representing a rust program. Contains
|
||||||
|
/// extra information for joining up this rust code with javascript.
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Default, Clone)]
|
||||||
|
pub struct Program {
|
||||||
|
/// rust -> js interfaces
|
||||||
|
pub exports: Vec<Export>,
|
||||||
|
/// js -> rust interfaces
|
||||||
|
pub imports: Vec<Import>,
|
||||||
|
/// rust enums
|
||||||
|
pub enums: Vec<Enum>,
|
||||||
|
/// rust structs
|
||||||
|
pub structs: Vec<Struct>,
|
||||||
|
/// custom typescript sections to be included in the definition file
|
||||||
|
pub typescript_custom_sections: Vec<String>,
|
||||||
|
/// Inline JS snippets
|
||||||
|
pub inline_js: Vec<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Program {
|
||||||
|
/// Returns true if the Program is empty
|
||||||
|
pub fn is_empty(&self) -> bool {
|
||||||
|
self.exports.is_empty()
|
||||||
|
&& self.imports.is_empty()
|
||||||
|
&& self.enums.is_empty()
|
||||||
|
&& self.structs.is_empty()
|
||||||
|
&& self.typescript_custom_sections.is_empty()
|
||||||
|
&& self.inline_js.is_empty()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A rust to js interface. Allows interaction with rust objects/functions
|
||||||
|
/// from javascript.
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Export {
|
||||||
|
/// Comments extracted from the rust source.
|
||||||
|
pub comments: Vec<String>,
|
||||||
|
/// The rust function
|
||||||
|
pub function: Function,
|
||||||
|
/// The class name in JS this is attached to
|
||||||
|
pub js_class: Option<String>,
|
||||||
|
/// The kind (static, named, regular)
|
||||||
|
pub method_kind: MethodKind,
|
||||||
|
/// The type of `self` (either `self`, `&self`, or `&mut self`)
|
||||||
|
pub method_self: Option<MethodSelf>,
|
||||||
|
/// The struct name, in Rust, this is attached to
|
||||||
|
pub rust_class: Option<Ident>,
|
||||||
|
/// The name of the rust function/method on the rust side.
|
||||||
|
pub rust_name: Ident,
|
||||||
|
/// Whether or not this function should be flagged as the wasm start
|
||||||
|
/// function.
|
||||||
|
pub start: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The 3 types variations of `self`.
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum MethodSelf {
|
||||||
|
/// `self`
|
||||||
|
ByValue,
|
||||||
|
/// `&mut self`
|
||||||
|
RefMutable,
|
||||||
|
/// `&self`
|
||||||
|
RefShared,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Things imported from a JS module (in an `extern` block)
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Import {
|
||||||
|
/// The type of module being imported from, if any
|
||||||
|
pub module: Option<ImportModule>,
|
||||||
|
/// The namespace to access the item through, if any
|
||||||
|
pub js_namespace: Option<Vec<String>>,
|
||||||
|
/// The type of item being imported
|
||||||
|
pub kind: ImportKind,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The possible types of module to import from
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum ImportModule {
|
||||||
|
/// Import from the named module, with relative paths interpreted
|
||||||
|
Named(String, Span),
|
||||||
|
/// Import from the named module, without interpreting paths
|
||||||
|
RawNamed(String, Span),
|
||||||
|
/// Import from an inline JS snippet
|
||||||
|
Inline(usize, Span),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Hash for ImportModule {
|
||||||
|
fn hash<H: Hasher>(&self, h: &mut H) {
|
||||||
|
match self {
|
||||||
|
ImportModule::Named(name, _) => (1u8, name).hash(h),
|
||||||
|
ImportModule::Inline(idx, _) => (2u8, idx).hash(h),
|
||||||
|
ImportModule::RawNamed(name, _) => (3u8, name).hash(h),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The type of item being imported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum ImportKind {
|
||||||
|
/// Importing a function
|
||||||
|
Function(ImportFunction),
|
||||||
|
/// Importing a static value
|
||||||
|
Static(ImportStatic),
|
||||||
|
/// Importing a type/class
|
||||||
|
Type(ImportType),
|
||||||
|
/// Importing a JS enum
|
||||||
|
Enum(ImportEnum),
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A function being imported from JS
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct ImportFunction {
|
||||||
|
/// The full signature of the function
|
||||||
|
pub function: Function,
|
||||||
|
/// The name rust code will use
|
||||||
|
pub rust_name: Ident,
|
||||||
|
/// The type being returned
|
||||||
|
pub js_ret: Option<syn::Type>,
|
||||||
|
/// Whether to catch JS exceptions
|
||||||
|
pub catch: bool,
|
||||||
|
/// Whether the function is variadic on the JS side
|
||||||
|
pub variadic: bool,
|
||||||
|
/// Whether the function should use structural type checking
|
||||||
|
pub structural: bool,
|
||||||
|
/// Causes the Builder (See cli-support::js::binding::Builder) to error out if
|
||||||
|
/// it finds itself generating code for a function with this signature
|
||||||
|
pub assert_no_shim: bool,
|
||||||
|
/// The kind of function being imported
|
||||||
|
pub kind: ImportFunctionKind,
|
||||||
|
/// The shim name to use in the generated code. The 'shim' is a function that appears in
|
||||||
|
/// the generated JS as a wrapper around the actual function to import, performing any
|
||||||
|
/// necessary conversions (EG adding a try/catch to change a thrown error into a Result)
|
||||||
|
pub shim: Ident,
|
||||||
|
/// The doc comment on this import, if one is provided
|
||||||
|
pub doc_comment: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The type of a function being imported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum ImportFunctionKind {
|
||||||
|
/// A class method
|
||||||
|
Method {
|
||||||
|
/// The name of the class for this method, in JS
|
||||||
|
class: String,
|
||||||
|
/// The type of the class for this method, in Rust
|
||||||
|
ty: syn::Type,
|
||||||
|
/// The kind of method this is
|
||||||
|
kind: MethodKind,
|
||||||
|
},
|
||||||
|
/// A standard function
|
||||||
|
Normal,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The type of a method
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum MethodKind {
|
||||||
|
/// A class constructor
|
||||||
|
Constructor,
|
||||||
|
/// Any other kind of method
|
||||||
|
Operation(Operation),
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The operation performed by a class method
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Operation {
|
||||||
|
/// Whether this method is static
|
||||||
|
pub is_static: bool,
|
||||||
|
/// The internal kind of this Operation
|
||||||
|
pub kind: OperationKind,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The kind of operation performed by a method
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub enum OperationKind {
|
||||||
|
/// A standard method, nothing special
|
||||||
|
Regular,
|
||||||
|
/// A method for getting the value of the provided Ident
|
||||||
|
Getter(Option<Ident>),
|
||||||
|
/// A method for setting the value of the provided Ident
|
||||||
|
Setter(Option<Ident>),
|
||||||
|
/// A dynamically intercepted getter
|
||||||
|
IndexingGetter,
|
||||||
|
/// A dynamically intercepted setter
|
||||||
|
IndexingSetter,
|
||||||
|
/// A dynamically intercepted deleter
|
||||||
|
IndexingDeleter,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The type of a static being imported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct ImportStatic {
|
||||||
|
/// The visibility of this static in Rust
|
||||||
|
pub vis: syn::Visibility,
|
||||||
|
/// The type of static being imported
|
||||||
|
pub ty: syn::Type,
|
||||||
|
/// The name of the shim function used to access this static
|
||||||
|
pub shim: Ident,
|
||||||
|
/// The name of this static on the Rust side
|
||||||
|
pub rust_name: Ident,
|
||||||
|
/// The name of this static on the JS side
|
||||||
|
pub js_name: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The metadata for a type being imported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct ImportType {
|
||||||
|
/// The visibility of this type in Rust
|
||||||
|
pub vis: syn::Visibility,
|
||||||
|
/// The name of this type on the Rust side
|
||||||
|
pub rust_name: Ident,
|
||||||
|
/// The name of this type on the JS side
|
||||||
|
pub js_name: String,
|
||||||
|
/// The custom attributes to apply to this type
|
||||||
|
pub attrs: Vec<syn::Attribute>,
|
||||||
|
/// The TS definition to generate for this type
|
||||||
|
pub typescript_type: Option<String>,
|
||||||
|
/// The doc comment applied to this type, if one exists
|
||||||
|
pub doc_comment: Option<String>,
|
||||||
|
/// The name of the shim to check instanceof for this type
|
||||||
|
pub instanceof_shim: String,
|
||||||
|
/// The name of the remote function to use for the generated is_type_of
|
||||||
|
pub is_type_of: Option<syn::Expr>,
|
||||||
|
/// The list of classes this extends, if any
|
||||||
|
pub extends: Vec<syn::Path>,
|
||||||
|
/// A custom prefix to add and attempt to fall back to, if the type isn't found
|
||||||
|
pub vendor_prefixes: Vec<Ident>,
|
||||||
|
/// If present, don't generate a `Deref` impl
|
||||||
|
pub no_deref: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The metadata for an Enum being imported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct ImportEnum {
|
||||||
|
/// The Rust enum's visibility
|
||||||
|
pub vis: syn::Visibility,
|
||||||
|
/// The Rust enum's identifiers
|
||||||
|
pub name: Ident,
|
||||||
|
/// The Rust identifiers for the variants
|
||||||
|
pub variants: Vec<Ident>,
|
||||||
|
/// The JS string values of the variants
|
||||||
|
pub variant_values: Vec<String>,
|
||||||
|
/// Attributes to apply to the Rust enum
|
||||||
|
pub rust_attrs: Vec<syn::Attribute>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Information about a function being imported or exported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Function {
|
||||||
|
/// The name of the function
|
||||||
|
pub name: String,
|
||||||
|
/// The span of the function's name in Rust code
|
||||||
|
pub name_span: Span,
|
||||||
|
/// Whether the function has a js_name attribute
|
||||||
|
pub renamed_via_js_name: bool,
|
||||||
|
/// The arguments to the function
|
||||||
|
pub arguments: Vec<syn::PatType>,
|
||||||
|
/// The return type of the function, if provided
|
||||||
|
pub ret: Option<syn::Type>,
|
||||||
|
/// Any custom attributes being applied to the function
|
||||||
|
pub rust_attrs: Vec<syn::Attribute>,
|
||||||
|
/// The visibility of this function in Rust
|
||||||
|
pub rust_vis: syn::Visibility,
|
||||||
|
/// Whether this is an `async` function
|
||||||
|
pub r#async: bool,
|
||||||
|
/// Whether to generate a typescript definition for this function
|
||||||
|
pub generate_typescript: bool,
|
||||||
|
/// Whether this is a function with a variadict parameter
|
||||||
|
pub variadic: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Information about a Struct being exported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Struct {
|
||||||
|
/// The name of the struct in Rust code
|
||||||
|
pub rust_name: Ident,
|
||||||
|
/// The name of the struct in JS code
|
||||||
|
pub js_name: String,
|
||||||
|
/// All the fields of this struct to export
|
||||||
|
pub fields: Vec<StructField>,
|
||||||
|
/// The doc comments on this struct, if provided
|
||||||
|
pub comments: Vec<String>,
|
||||||
|
/// Whether this struct is inspectable (provides toJSON/toString properties to JS)
|
||||||
|
pub is_inspectable: bool,
|
||||||
|
/// Whether to generate a typescript definition for this struct
|
||||||
|
pub generate_typescript: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The field of a struct
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct StructField {
|
||||||
|
/// The name of the field in Rust code
|
||||||
|
pub rust_name: syn::Member,
|
||||||
|
/// The name of the field in JS code
|
||||||
|
pub js_name: String,
|
||||||
|
/// The name of the struct this field is part of
|
||||||
|
pub struct_name: Ident,
|
||||||
|
/// Whether this value is read-only to JS
|
||||||
|
pub readonly: bool,
|
||||||
|
/// The type of this field
|
||||||
|
pub ty: syn::Type,
|
||||||
|
/// The name of the getter shim for this field
|
||||||
|
pub getter: Ident,
|
||||||
|
/// The name of the setter shim for this field
|
||||||
|
pub setter: Ident,
|
||||||
|
/// The doc comments on this field, if any
|
||||||
|
pub comments: Vec<String>,
|
||||||
|
/// Whether to generate a typescript definition for this field
|
||||||
|
pub generate_typescript: bool,
|
||||||
|
/// Whether to use .clone() in the auto-generated getter for this field
|
||||||
|
pub getter_with_clone: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Information about an Enum being exported
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Enum {
|
||||||
|
/// The name of this enum in Rust code
|
||||||
|
pub rust_name: Ident,
|
||||||
|
/// The name of this enum in JS code
|
||||||
|
pub js_name: String,
|
||||||
|
/// The variants provided by this enum
|
||||||
|
pub variants: Vec<Variant>,
|
||||||
|
/// The doc comments on this enum, if any
|
||||||
|
pub comments: Vec<String>,
|
||||||
|
/// The value to use for a `none` variant of the enum
|
||||||
|
pub hole: u32,
|
||||||
|
/// Whether to generate a typescript definition for this enum
|
||||||
|
pub generate_typescript: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The variant of an enum
|
||||||
|
#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct Variant {
|
||||||
|
/// The name of this variant
|
||||||
|
pub name: Ident,
|
||||||
|
/// The backing value of this variant
|
||||||
|
pub value: u32,
|
||||||
|
/// The doc comments on this variant, if any
|
||||||
|
pub comments: Vec<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Unused, the type of an argument to / return from a function
|
||||||
|
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
||||||
|
pub enum TypeKind {
|
||||||
|
/// A by-reference arg, EG `&T`
|
||||||
|
ByRef,
|
||||||
|
/// A by-mutable-reference arg, EG `&mut T`
|
||||||
|
ByMutRef,
|
||||||
|
/// A by-value arg, EG `T`
|
||||||
|
ByValue,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Unused, the location of a type for a function argument (import/export, argument/ret)
|
||||||
|
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
||||||
|
pub enum TypeLocation {
|
||||||
|
/// An imported argument (JS side type)
|
||||||
|
ImportArgument,
|
||||||
|
/// An imported return
|
||||||
|
ImportRet,
|
||||||
|
/// An exported argument (Rust side type)
|
||||||
|
ExportArgument,
|
||||||
|
/// An exported return
|
||||||
|
ExportRet,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Export {
|
||||||
|
/// Mangles a rust -> javascript export, so that the created Ident will be unique over function
|
||||||
|
/// name and class name, if the function belongs to a javascript class.
|
||||||
|
pub(crate) fn rust_symbol(&self) -> Ident {
|
||||||
|
let mut generated_name = String::from("__wasm_bindgen_generated");
|
||||||
|
if let Some(class) = &self.js_class {
|
||||||
|
generated_name.push_str("_");
|
||||||
|
generated_name.push_str(class);
|
||||||
|
}
|
||||||
|
generated_name.push_str("_");
|
||||||
|
generated_name.push_str(&self.function.name.to_string());
|
||||||
|
Ident::new(&generated_name, Span::call_site())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// This is the name of the shim function that gets exported and takes the raw
|
||||||
|
/// ABI form of its arguments and converts them back into their normal,
|
||||||
|
/// "high level" form before calling the actual function.
|
||||||
|
pub(crate) fn export_name(&self) -> String {
|
||||||
|
let fn_name = self.function.name.to_string();
|
||||||
|
match &self.js_class {
|
||||||
|
Some(class) => shared::struct_function_export_name(class, &fn_name),
|
||||||
|
None => shared::free_function_export_name(&fn_name),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ImportKind {
|
||||||
|
/// Whether this type can be inside an `impl` block.
|
||||||
|
pub fn fits_on_impl(&self) -> bool {
|
||||||
|
match *self {
|
||||||
|
ImportKind::Function(_) => true,
|
||||||
|
ImportKind::Static(_) => false,
|
||||||
|
ImportKind::Type(_) => false,
|
||||||
|
ImportKind::Enum(_) => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Function {
|
||||||
|
/// If the rust object has a `fn xxx(&self) -> MyType` method, get the name for a getter in
|
||||||
|
/// javascript (in this case `xxx`, so you can write `val = obj.xxx`)
|
||||||
|
pub fn infer_getter_property(&self) -> &str {
|
||||||
|
&self.name
|
||||||
|
}
|
||||||
|
|
||||||
|
/// If the rust object has a `fn set_xxx(&mut self, MyType)` style method, get the name
|
||||||
|
/// for a setter in javascript (in this case `xxx`, so you can write `obj.xxx = val`)
|
||||||
|
pub fn infer_setter_property(&self) -> Result<String, Diagnostic> {
|
||||||
|
let name = self.name.to_string();
|
||||||
|
|
||||||
|
// Otherwise we infer names based on the Rust function name.
|
||||||
|
if !name.starts_with("set_") {
|
||||||
|
bail_span!(
|
||||||
|
syn::token::Pub(self.name_span),
|
||||||
|
"setters must start with `set_`, found: {}",
|
||||||
|
name,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
Ok(name[4..].to_string())
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,536 @@
|
||||||
|
use crate::util::ShortHash;
|
||||||
|
use proc_macro2::{Ident, Span};
|
||||||
|
use std::cell::{Cell, RefCell};
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::env;
|
||||||
|
use std::fs;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
use crate::ast;
|
||||||
|
use crate::Diagnostic;
|
||||||
|
|
||||||
|
pub struct EncodeResult {
|
||||||
|
pub custom_section: Vec<u8>,
|
||||||
|
pub included_files: Vec<PathBuf>,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn encode(program: &ast::Program) -> Result<EncodeResult, Diagnostic> {
|
||||||
|
let mut e = Encoder::new();
|
||||||
|
let i = Interner::new();
|
||||||
|
shared_program(program, &i)?.encode(&mut e);
|
||||||
|
let custom_section = e.finish();
|
||||||
|
let included_files = i
|
||||||
|
.files
|
||||||
|
.borrow()
|
||||||
|
.values()
|
||||||
|
.map(|p| &p.path)
|
||||||
|
.cloned()
|
||||||
|
.collect();
|
||||||
|
Ok(EncodeResult {
|
||||||
|
custom_section,
|
||||||
|
included_files,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Interner {
|
||||||
|
bump: bumpalo::Bump,
|
||||||
|
files: RefCell<HashMap<String, LocalFile>>,
|
||||||
|
root: PathBuf,
|
||||||
|
crate_name: String,
|
||||||
|
has_package_json: Cell<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
struct LocalFile {
|
||||||
|
path: PathBuf,
|
||||||
|
definition: Span,
|
||||||
|
new_identifier: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Interner {
|
||||||
|
fn new() -> Interner {
|
||||||
|
let root = env::var_os("CARGO_MANIFEST_DIR")
|
||||||
|
.expect("should have CARGO_MANIFEST_DIR env var")
|
||||||
|
.into();
|
||||||
|
let crate_name = env::var("CARGO_PKG_NAME").expect("should have CARGO_PKG_NAME env var");
|
||||||
|
Interner {
|
||||||
|
bump: bumpalo::Bump::new(),
|
||||||
|
files: RefCell::new(HashMap::new()),
|
||||||
|
root,
|
||||||
|
crate_name,
|
||||||
|
has_package_json: Cell::new(false),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn intern(&self, s: &Ident) -> &str {
|
||||||
|
self.intern_str(&s.to_string())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn intern_str(&self, s: &str) -> &str {
|
||||||
|
// NB: eventually this could be used to intern `s` to only allocate one
|
||||||
|
// copy, but for now let's just "transmute" `s` to have the same
|
||||||
|
// lifetime as this struct itself (which is our main goal here)
|
||||||
|
self.bump.alloc_str(s)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Given an import to a local module `id` this generates a unique module id
|
||||||
|
/// to assign to the contents of `id`.
|
||||||
|
///
|
||||||
|
/// Note that repeated invocations of this function will be memoized, so the
|
||||||
|
/// same `id` will always return the same resulting unique `id`.
|
||||||
|
fn resolve_import_module(&self, id: &str, span: Span) -> Result<ImportModule, Diagnostic> {
|
||||||
|
let mut files = self.files.borrow_mut();
|
||||||
|
if let Some(file) = files.get(id) {
|
||||||
|
return Ok(ImportModule::Named(self.intern_str(&file.new_identifier)));
|
||||||
|
}
|
||||||
|
self.check_for_package_json();
|
||||||
|
let path = if id.starts_with("/") {
|
||||||
|
self.root.join(&id[1..])
|
||||||
|
} else if id.starts_with("./") || id.starts_with("../") {
|
||||||
|
let msg = "relative module paths aren't supported yet";
|
||||||
|
return Err(Diagnostic::span_error(span, msg));
|
||||||
|
} else {
|
||||||
|
return Ok(ImportModule::RawNamed(self.intern_str(id)));
|
||||||
|
};
|
||||||
|
|
||||||
|
// Generate a unique ID which is somewhat readable as well, so mix in
|
||||||
|
// the crate name, hash to make it unique, and then the original path.
|
||||||
|
let new_identifier = format!("{}{}", self.unique_crate_identifier(), id);
|
||||||
|
let file = LocalFile {
|
||||||
|
path,
|
||||||
|
definition: span,
|
||||||
|
new_identifier,
|
||||||
|
};
|
||||||
|
files.insert(id.to_string(), file);
|
||||||
|
drop(files);
|
||||||
|
self.resolve_import_module(id, span)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn unique_crate_identifier(&self) -> String {
|
||||||
|
format!("{}-{}", self.crate_name, ShortHash(0))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_for_package_json(&self) {
|
||||||
|
if self.has_package_json.get() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let path = self.root.join("package.json");
|
||||||
|
if path.exists() {
|
||||||
|
self.has_package_json.set(true);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_program<'a>(
|
||||||
|
prog: &'a ast::Program,
|
||||||
|
intern: &'a Interner,
|
||||||
|
) -> Result<Program<'a>, Diagnostic> {
|
||||||
|
Ok(Program {
|
||||||
|
exports: prog
|
||||||
|
.exports
|
||||||
|
.iter()
|
||||||
|
.map(|a| shared_export(a, intern))
|
||||||
|
.collect::<Result<Vec<_>, _>>()?,
|
||||||
|
structs: prog
|
||||||
|
.structs
|
||||||
|
.iter()
|
||||||
|
.map(|a| shared_struct(a, intern))
|
||||||
|
.collect(),
|
||||||
|
enums: prog.enums.iter().map(|a| shared_enum(a, intern)).collect(),
|
||||||
|
imports: prog
|
||||||
|
.imports
|
||||||
|
.iter()
|
||||||
|
.map(|a| shared_import(a, intern))
|
||||||
|
.collect::<Result<Vec<_>, _>>()?,
|
||||||
|
typescript_custom_sections: prog
|
||||||
|
.typescript_custom_sections
|
||||||
|
.iter()
|
||||||
|
.map(|x| -> &'a str { &x })
|
||||||
|
.collect(),
|
||||||
|
local_modules: intern
|
||||||
|
.files
|
||||||
|
.borrow()
|
||||||
|
.values()
|
||||||
|
.map(|file| {
|
||||||
|
fs::read_to_string(&file.path)
|
||||||
|
.map(|s| LocalModule {
|
||||||
|
identifier: intern.intern_str(&file.new_identifier),
|
||||||
|
contents: intern.intern_str(&s),
|
||||||
|
})
|
||||||
|
.map_err(|e| {
|
||||||
|
let msg = format!("failed to read file `{}`: {}", file.path.display(), e);
|
||||||
|
Diagnostic::span_error(file.definition, msg)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.collect::<Result<Vec<_>, _>>()?,
|
||||||
|
inline_js: prog
|
||||||
|
.inline_js
|
||||||
|
.iter()
|
||||||
|
.map(|js| intern.intern_str(js))
|
||||||
|
.collect(),
|
||||||
|
unique_crate_identifier: intern.intern_str(&intern.unique_crate_identifier()),
|
||||||
|
package_json: if intern.has_package_json.get() {
|
||||||
|
Some(intern.intern_str(intern.root.join("package.json").to_str().unwrap()))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
},
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_export<'a>(
|
||||||
|
export: &'a ast::Export,
|
||||||
|
intern: &'a Interner,
|
||||||
|
) -> Result<Export<'a>, Diagnostic> {
|
||||||
|
let consumed = match export.method_self {
|
||||||
|
Some(ast::MethodSelf::ByValue) => true,
|
||||||
|
_ => false,
|
||||||
|
};
|
||||||
|
let method_kind = from_ast_method_kind(&export.function, intern, &export.method_kind)?;
|
||||||
|
Ok(Export {
|
||||||
|
class: export.js_class.as_ref().map(|s| &**s),
|
||||||
|
comments: export.comments.iter().map(|s| &**s).collect(),
|
||||||
|
consumed,
|
||||||
|
function: shared_function(&export.function, intern),
|
||||||
|
method_kind,
|
||||||
|
start: export.start,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Function<'a> {
|
||||||
|
let arg_names = func
|
||||||
|
.arguments
|
||||||
|
.iter()
|
||||||
|
.enumerate()
|
||||||
|
.map(|(idx, arg)| {
|
||||||
|
if let syn::Pat::Ident(x) = &*arg.pat {
|
||||||
|
return x.ident.to_string();
|
||||||
|
}
|
||||||
|
format!("arg{}", idx)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
Function {
|
||||||
|
arg_names,
|
||||||
|
asyncness: func.r#async,
|
||||||
|
name: &func.name,
|
||||||
|
generate_typescript: func.generate_typescript,
|
||||||
|
variadic: func.variadic,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_enum<'a>(e: &'a ast::Enum, intern: &'a Interner) -> Enum<'a> {
|
||||||
|
Enum {
|
||||||
|
name: &e.js_name,
|
||||||
|
variants: e
|
||||||
|
.variants
|
||||||
|
.iter()
|
||||||
|
.map(|v| shared_variant(v, intern))
|
||||||
|
.collect(),
|
||||||
|
comments: e.comments.iter().map(|s| &**s).collect(),
|
||||||
|
generate_typescript: e.generate_typescript,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_variant<'a>(v: &'a ast::Variant, intern: &'a Interner) -> EnumVariant<'a> {
|
||||||
|
EnumVariant {
|
||||||
|
name: intern.intern(&v.name),
|
||||||
|
value: v.value,
|
||||||
|
comments: v.comments.iter().map(|s| &**s).collect(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_import<'a>(i: &'a ast::Import, intern: &'a Interner) -> Result<Import<'a>, Diagnostic> {
|
||||||
|
Ok(Import {
|
||||||
|
module: i
|
||||||
|
.module
|
||||||
|
.as_ref()
|
||||||
|
.map(|m| shared_module(m, intern))
|
||||||
|
.transpose()?,
|
||||||
|
js_namespace: i.js_namespace.clone(),
|
||||||
|
kind: shared_import_kind(&i.kind, intern)?,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_module<'a>(
|
||||||
|
m: &'a ast::ImportModule,
|
||||||
|
intern: &'a Interner,
|
||||||
|
) -> Result<ImportModule<'a>, Diagnostic> {
|
||||||
|
Ok(match m {
|
||||||
|
ast::ImportModule::Named(m, span) => intern.resolve_import_module(m, *span)?,
|
||||||
|
ast::ImportModule::RawNamed(m, _span) => ImportModule::RawNamed(intern.intern_str(m)),
|
||||||
|
ast::ImportModule::Inline(idx, _) => ImportModule::Inline(*idx as u32),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_import_kind<'a>(
|
||||||
|
i: &'a ast::ImportKind,
|
||||||
|
intern: &'a Interner,
|
||||||
|
) -> Result<ImportKind<'a>, Diagnostic> {
|
||||||
|
Ok(match i {
|
||||||
|
ast::ImportKind::Function(f) => ImportKind::Function(shared_import_function(f, intern)?),
|
||||||
|
ast::ImportKind::Static(f) => ImportKind::Static(shared_import_static(f, intern)),
|
||||||
|
ast::ImportKind::Type(f) => ImportKind::Type(shared_import_type(f, intern)),
|
||||||
|
ast::ImportKind::Enum(f) => ImportKind::Enum(shared_import_enum(f, intern)),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_import_function<'a>(
|
||||||
|
i: &'a ast::ImportFunction,
|
||||||
|
intern: &'a Interner,
|
||||||
|
) -> Result<ImportFunction<'a>, Diagnostic> {
|
||||||
|
let method = match &i.kind {
|
||||||
|
ast::ImportFunctionKind::Method { class, kind, .. } => {
|
||||||
|
let kind = from_ast_method_kind(&i.function, intern, kind)?;
|
||||||
|
Some(MethodData { class, kind })
|
||||||
|
}
|
||||||
|
ast::ImportFunctionKind::Normal => None,
|
||||||
|
};
|
||||||
|
|
||||||
|
Ok(ImportFunction {
|
||||||
|
shim: intern.intern(&i.shim),
|
||||||
|
catch: i.catch,
|
||||||
|
method,
|
||||||
|
assert_no_shim: i.assert_no_shim,
|
||||||
|
structural: i.structural,
|
||||||
|
function: shared_function(&i.function, intern),
|
||||||
|
variadic: i.variadic,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_import_static<'a>(i: &'a ast::ImportStatic, intern: &'a Interner) -> ImportStatic<'a> {
|
||||||
|
ImportStatic {
|
||||||
|
name: &i.js_name,
|
||||||
|
shim: intern.intern(&i.shim),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_import_type<'a>(i: &'a ast::ImportType, intern: &'a Interner) -> ImportType<'a> {
|
||||||
|
ImportType {
|
||||||
|
name: &i.js_name,
|
||||||
|
instanceof_shim: &i.instanceof_shim,
|
||||||
|
vendor_prefixes: i.vendor_prefixes.iter().map(|x| intern.intern(x)).collect(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_import_enum<'a>(_i: &'a ast::ImportEnum, _intern: &'a Interner) -> ImportEnum {
|
||||||
|
ImportEnum {}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_struct<'a>(s: &'a ast::Struct, intern: &'a Interner) -> Struct<'a> {
|
||||||
|
Struct {
|
||||||
|
name: &s.js_name,
|
||||||
|
fields: s
|
||||||
|
.fields
|
||||||
|
.iter()
|
||||||
|
.map(|s| shared_struct_field(s, intern))
|
||||||
|
.collect(),
|
||||||
|
comments: s.comments.iter().map(|s| &**s).collect(),
|
||||||
|
is_inspectable: s.is_inspectable,
|
||||||
|
generate_typescript: s.generate_typescript,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn shared_struct_field<'a>(s: &'a ast::StructField, _intern: &'a Interner) -> StructField<'a> {
|
||||||
|
StructField {
|
||||||
|
name: &s.js_name,
|
||||||
|
readonly: s.readonly,
|
||||||
|
comments: s.comments.iter().map(|s| &**s).collect(),
|
||||||
|
generate_typescript: s.generate_typescript,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
trait Encode {
|
||||||
|
fn encode(&self, dst: &mut Encoder);
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Encoder {
|
||||||
|
dst: Vec<u8>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Encoder {
|
||||||
|
fn new() -> Encoder {
|
||||||
|
Encoder {
|
||||||
|
dst: vec![0, 0, 0, 0],
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finish(mut self) -> Vec<u8> {
|
||||||
|
let len = (self.dst.len() - 4) as u32;
|
||||||
|
self.dst[..4].copy_from_slice(&len.to_le_bytes()[..]);
|
||||||
|
self.dst
|
||||||
|
}
|
||||||
|
|
||||||
|
fn byte(&mut self, byte: u8) {
|
||||||
|
self.dst.push(byte);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Encode for bool {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
dst.byte(*self as u8);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Encode for u32 {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
let mut val = *self;
|
||||||
|
while (val >> 7) != 0 {
|
||||||
|
dst.byte((val as u8) | 0x80);
|
||||||
|
val >>= 7;
|
||||||
|
}
|
||||||
|
assert_eq!(val >> 7, 0);
|
||||||
|
dst.byte(val as u8);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Encode for usize {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
assert!(*self <= u32::max_value() as usize);
|
||||||
|
(*self as u32).encode(dst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Encode for &'a [u8] {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
self.len().encode(dst);
|
||||||
|
dst.dst.extend_from_slice(*self);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Encode for &'a str {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
self.as_bytes().encode(dst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Encode for String {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
self.as_bytes().encode(dst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Encode> Encode for Vec<T> {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
self.len().encode(dst);
|
||||||
|
for item in self {
|
||||||
|
item.encode(dst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Encode> Encode for Option<T> {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
match self {
|
||||||
|
None => dst.byte(0),
|
||||||
|
Some(val) => {
|
||||||
|
dst.byte(1);
|
||||||
|
val.encode(dst)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! encode_struct {
|
||||||
|
($name:ident ($($lt:tt)*) $($field:ident: $ty:ty,)*) => {
|
||||||
|
struct $name $($lt)* {
|
||||||
|
$($field: $ty,)*
|
||||||
|
}
|
||||||
|
|
||||||
|
impl $($lt)* Encode for $name $($lt)* {
|
||||||
|
fn encode(&self, _dst: &mut Encoder) {
|
||||||
|
$(self.$field.encode(_dst);)*
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! encode_enum {
|
||||||
|
($name:ident ($($lt:tt)*) $($fields:tt)*) => (
|
||||||
|
enum $name $($lt)* { $($fields)* }
|
||||||
|
|
||||||
|
impl$($lt)* Encode for $name $($lt)* {
|
||||||
|
fn encode(&self, dst: &mut Encoder) {
|
||||||
|
use self::$name::*;
|
||||||
|
encode_enum!(@arms self dst (0) () $($fields)*)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
);
|
||||||
|
|
||||||
|
(@arms $me:ident $dst:ident ($cnt:expr) ($($arms:tt)*)) => (
|
||||||
|
encode_enum!(@expr match $me { $($arms)* })
|
||||||
|
);
|
||||||
|
|
||||||
|
(@arms $me:ident $dst:ident ($cnt:expr) ($($arms:tt)*) $name:ident, $($rest:tt)*) => (
|
||||||
|
encode_enum!(
|
||||||
|
@arms
|
||||||
|
$me
|
||||||
|
$dst
|
||||||
|
($cnt+1)
|
||||||
|
($($arms)* $name => $dst.byte($cnt),)
|
||||||
|
$($rest)*
|
||||||
|
)
|
||||||
|
);
|
||||||
|
|
||||||
|
(@arms $me:ident $dst:ident ($cnt:expr) ($($arms:tt)*) $name:ident($t:ty), $($rest:tt)*) => (
|
||||||
|
encode_enum!(
|
||||||
|
@arms
|
||||||
|
$me
|
||||||
|
$dst
|
||||||
|
($cnt+1)
|
||||||
|
($($arms)* $name(val) => { $dst.byte($cnt); val.encode($dst) })
|
||||||
|
$($rest)*
|
||||||
|
)
|
||||||
|
);
|
||||||
|
|
||||||
|
(@expr $e:expr) => ($e);
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! encode_api {
|
||||||
|
() => ();
|
||||||
|
(struct $name:ident<'a> { $($fields:tt)* } $($rest:tt)*) => (
|
||||||
|
encode_struct!($name (<'a>) $($fields)*);
|
||||||
|
encode_api!($($rest)*);
|
||||||
|
);
|
||||||
|
(struct $name:ident { $($fields:tt)* } $($rest:tt)*) => (
|
||||||
|
encode_struct!($name () $($fields)*);
|
||||||
|
encode_api!($($rest)*);
|
||||||
|
);
|
||||||
|
(enum $name:ident<'a> { $($variants:tt)* } $($rest:tt)*) => (
|
||||||
|
encode_enum!($name (<'a>) $($variants)*);
|
||||||
|
encode_api!($($rest)*);
|
||||||
|
);
|
||||||
|
(enum $name:ident { $($variants:tt)* } $($rest:tt)*) => (
|
||||||
|
encode_enum!($name () $($variants)*);
|
||||||
|
encode_api!($($rest)*);
|
||||||
|
);
|
||||||
|
}
|
||||||
|
wasm_bindgen_shared::shared_api!(encode_api);
|
||||||
|
|
||||||
|
fn from_ast_method_kind<'a>(
|
||||||
|
function: &'a ast::Function,
|
||||||
|
intern: &'a Interner,
|
||||||
|
method_kind: &'a ast::MethodKind,
|
||||||
|
) -> Result<MethodKind<'a>, Diagnostic> {
|
||||||
|
Ok(match method_kind {
|
||||||
|
ast::MethodKind::Constructor => MethodKind::Constructor,
|
||||||
|
ast::MethodKind::Operation(ast::Operation { is_static, kind }) => {
|
||||||
|
let is_static = *is_static;
|
||||||
|
let kind = match kind {
|
||||||
|
ast::OperationKind::Getter(g) => {
|
||||||
|
let g = g.as_ref().map(|g| intern.intern(g));
|
||||||
|
OperationKind::Getter(g.unwrap_or_else(|| function.infer_getter_property()))
|
||||||
|
}
|
||||||
|
ast::OperationKind::Regular => OperationKind::Regular,
|
||||||
|
ast::OperationKind::Setter(s) => {
|
||||||
|
let s = s.as_ref().map(|s| intern.intern(s));
|
||||||
|
OperationKind::Setter(match s {
|
||||||
|
Some(s) => s,
|
||||||
|
None => intern.intern_str(&function.infer_setter_property()?),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
ast::OperationKind::IndexingGetter => OperationKind::IndexingGetter,
|
||||||
|
ast::OperationKind::IndexingSetter => OperationKind::IndexingSetter,
|
||||||
|
ast::OperationKind::IndexingDeleter => OperationKind::IndexingDeleter,
|
||||||
|
};
|
||||||
|
MethodKind::Operation(Operation { is_static, kind })
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,134 @@
|
||||||
|
use proc_macro2::*;
|
||||||
|
use quote::{ToTokens, TokenStreamExt};
|
||||||
|
use syn::parse::Error;
|
||||||
|
|
||||||
|
/// Provide a Diagnostic with the given span and message
|
||||||
|
#[macro_export]
|
||||||
|
macro_rules! err_span {
|
||||||
|
($span:expr, $($msg:tt)*) => (
|
||||||
|
$crate::Diagnostic::spanned_error(&$span, format!($($msg)*))
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Immediately fail and return an Err, with the arguments passed to err_span!
|
||||||
|
#[macro_export]
|
||||||
|
macro_rules! bail_span {
|
||||||
|
($($t:tt)*) => (
|
||||||
|
return Err(err_span!($($t)*).into())
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A struct representing a diagnostic to emit to the end-user as an error.
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Diagnostic {
|
||||||
|
inner: Repr,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
enum Repr {
|
||||||
|
Single {
|
||||||
|
text: String,
|
||||||
|
span: Option<(Span, Span)>,
|
||||||
|
},
|
||||||
|
SynError(Error),
|
||||||
|
Multi {
|
||||||
|
diagnostics: Vec<Diagnostic>,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Diagnostic {
|
||||||
|
/// Generate a `Diagnostic` from an informational message with no Span
|
||||||
|
pub fn error<T: Into<String>>(text: T) -> Diagnostic {
|
||||||
|
Diagnostic {
|
||||||
|
inner: Repr::Single {
|
||||||
|
text: text.into(),
|
||||||
|
span: None,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generate a `Diagnostic` from a Span and an informational message
|
||||||
|
pub fn span_error<T: Into<String>>(span: Span, text: T) -> Diagnostic {
|
||||||
|
Diagnostic {
|
||||||
|
inner: Repr::Single {
|
||||||
|
text: text.into(),
|
||||||
|
span: Some((span, span)),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Generate a `Diagnostic` from the span of any tokenizable object and a message
|
||||||
|
pub fn spanned_error<T: Into<String>>(node: &dyn ToTokens, text: T) -> Diagnostic {
|
||||||
|
Diagnostic {
|
||||||
|
inner: Repr::Single {
|
||||||
|
text: text.into(),
|
||||||
|
span: extract_spans(node),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Attempt to generate a `Diagnostic` from a vector of other `Diagnostic` instances.
|
||||||
|
/// If the `Vec` is empty, returns `Ok(())`, otherwise returns the new `Diagnostic`
|
||||||
|
pub fn from_vec(diagnostics: Vec<Diagnostic>) -> Result<(), Diagnostic> {
|
||||||
|
if diagnostics.len() == 0 {
|
||||||
|
Ok(())
|
||||||
|
} else {
|
||||||
|
Err(Diagnostic {
|
||||||
|
inner: Repr::Multi { diagnostics },
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Immediately trigger a panic from this `Diagnostic`
|
||||||
|
#[allow(unconditional_recursion)]
|
||||||
|
pub fn panic(&self) -> ! {
|
||||||
|
match &self.inner {
|
||||||
|
Repr::Single { text, .. } => panic!("{}", text),
|
||||||
|
Repr::SynError(error) => panic!("{}", error),
|
||||||
|
Repr::Multi { diagnostics } => diagnostics[0].panic(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<Error> for Diagnostic {
|
||||||
|
fn from(err: Error) -> Diagnostic {
|
||||||
|
Diagnostic {
|
||||||
|
inner: Repr::SynError(err),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn extract_spans(node: &dyn ToTokens) -> Option<(Span, Span)> {
|
||||||
|
let mut t = TokenStream::new();
|
||||||
|
node.to_tokens(&mut t);
|
||||||
|
let mut tokens = t.into_iter();
|
||||||
|
let start = tokens.next().map(|t| t.span());
|
||||||
|
let end = tokens.last().map(|t| t.span());
|
||||||
|
start.map(|start| (start, end.unwrap_or(start)))
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ToTokens for Diagnostic {
|
||||||
|
fn to_tokens(&self, dst: &mut TokenStream) {
|
||||||
|
match &self.inner {
|
||||||
|
Repr::Single { text, span } => {
|
||||||
|
let cs2 = (Span::call_site(), Span::call_site());
|
||||||
|
let (start, end) = span.unwrap_or(cs2);
|
||||||
|
dst.append(Ident::new("compile_error", start));
|
||||||
|
dst.append(Punct::new('!', Spacing::Alone));
|
||||||
|
let mut message = TokenStream::new();
|
||||||
|
message.append(Literal::string(text));
|
||||||
|
let mut group = Group::new(Delimiter::Brace, message);
|
||||||
|
group.set_span(end);
|
||||||
|
dst.append(group);
|
||||||
|
}
|
||||||
|
Repr::Multi { diagnostics } => {
|
||||||
|
for diagnostic in diagnostics {
|
||||||
|
diagnostic.to_tokens(dst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Repr::SynError(err) => {
|
||||||
|
err.to_compile_error().to_tokens(dst);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,40 @@
|
||||||
|
//! A common backend for bindgen crates.
|
||||||
|
//!
|
||||||
|
//! This (internal) crate provides functionality common to multiple bindgen
|
||||||
|
//! dependency crates. There are 4 main things exported from this crate:
|
||||||
|
//!
|
||||||
|
//! 1. [**`TryToTokens`**](./trait.TryToTokens.html)
|
||||||
|
//!
|
||||||
|
//! Provides the ability to attempt conversion from an AST struct
|
||||||
|
//! into a TokenStream
|
||||||
|
//!
|
||||||
|
//! 2. [**`Diagnostic`**](./struct.Diagnostic.html)
|
||||||
|
//!
|
||||||
|
//! A struct used to provide diagnostic responses for failures of said
|
||||||
|
//! tokenization
|
||||||
|
//!
|
||||||
|
//! 3. [**`ast`**](./ast/index.html)
|
||||||
|
//!
|
||||||
|
//! Abstract Syntax Tree types used to represent a Rust program, with
|
||||||
|
//! the necessary metadata to generate bindings for it
|
||||||
|
//!
|
||||||
|
//! 4. [**`util`**](./util/index.html)
|
||||||
|
//!
|
||||||
|
//! Common utilities for manipulating parsed types from syn
|
||||||
|
//!
|
||||||
|
|
||||||
|
#![recursion_limit = "256"]
|
||||||
|
#![cfg_attr(feature = "extra-traits", deny(missing_debug_implementations))]
|
||||||
|
#![deny(missing_docs)]
|
||||||
|
#![doc(html_root_url = "https://docs.rs/wasm-bindgen-backend/0.2")]
|
||||||
|
|
||||||
|
pub use crate::codegen::TryToTokens;
|
||||||
|
pub use crate::error::Diagnostic;
|
||||||
|
|
||||||
|
#[macro_use]
|
||||||
|
mod error;
|
||||||
|
|
||||||
|
pub mod ast;
|
||||||
|
mod codegen;
|
||||||
|
mod encode;
|
||||||
|
pub mod util;
|
||||||
|
|
@ -0,0 +1,161 @@
|
||||||
|
//! Common utility function for manipulating syn types and
|
||||||
|
//! handling parsed values
|
||||||
|
|
||||||
|
use std::collections::hash_map::DefaultHasher;
|
||||||
|
use std::env;
|
||||||
|
use std::fmt;
|
||||||
|
use std::hash::{Hash, Hasher};
|
||||||
|
use std::iter::FromIterator;
|
||||||
|
use std::sync::atomic::AtomicBool;
|
||||||
|
use std::sync::atomic::AtomicUsize;
|
||||||
|
use std::sync::atomic::Ordering::SeqCst;
|
||||||
|
|
||||||
|
use crate::ast;
|
||||||
|
use proc_macro2::{self, Ident};
|
||||||
|
|
||||||
|
/// Check whether a given `&str` is a Rust keyword
|
||||||
|
fn is_rust_keyword(name: &str) -> bool {
|
||||||
|
match name {
|
||||||
|
"abstract" | "alignof" | "as" | "become" | "box" | "break" | "const" | "continue"
|
||||||
|
| "crate" | "do" | "else" | "enum" | "extern" | "false" | "final" | "fn" | "for" | "if"
|
||||||
|
| "impl" | "in" | "let" | "loop" | "macro" | "match" | "mod" | "move" | "mut"
|
||||||
|
| "offsetof" | "override" | "priv" | "proc" | "pub" | "pure" | "ref" | "return"
|
||||||
|
| "Self" | "self" | "sizeof" | "static" | "struct" | "super" | "trait" | "true"
|
||||||
|
| "type" | "typeof" | "unsafe" | "unsized" | "use" | "virtual" | "where" | "while"
|
||||||
|
| "yield" | "bool" | "_" => true,
|
||||||
|
_ => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create an `Ident`, possibly mangling it if it conflicts with a Rust keyword.
|
||||||
|
pub fn rust_ident(name: &str) -> Ident {
|
||||||
|
if name == "" {
|
||||||
|
panic!("tried to create empty Ident (from \"\")");
|
||||||
|
} else if is_rust_keyword(name) {
|
||||||
|
Ident::new(&format!("{}_", name), proc_macro2::Span::call_site())
|
||||||
|
|
||||||
|
// we didn't historically have `async` in the `is_rust_keyword` list above,
|
||||||
|
// so for backwards compatibility reasons we need to generate an `async`
|
||||||
|
// identifier as well, but we'll be sure to use a raw identifier to ease
|
||||||
|
// compatibility with the 2018 edition.
|
||||||
|
//
|
||||||
|
// Note, though, that `proc-macro` doesn't support a normal way to create a
|
||||||
|
// raw identifier. To get around that we do some wonky parsing to
|
||||||
|
// roundaboutly create one.
|
||||||
|
} else if name == "async" {
|
||||||
|
let ident = "r#async"
|
||||||
|
.parse::<proc_macro2::TokenStream>()
|
||||||
|
.unwrap()
|
||||||
|
.into_iter()
|
||||||
|
.next()
|
||||||
|
.unwrap();
|
||||||
|
match ident {
|
||||||
|
proc_macro2::TokenTree::Ident(i) => i,
|
||||||
|
_ => unreachable!(),
|
||||||
|
}
|
||||||
|
} else if name.chars().next().unwrap().is_ascii_digit() {
|
||||||
|
Ident::new(&format!("N{}", name), proc_macro2::Span::call_site())
|
||||||
|
} else {
|
||||||
|
raw_ident(name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create an `Ident` without checking to see if it conflicts with a Rust
|
||||||
|
/// keyword.
|
||||||
|
pub fn raw_ident(name: &str) -> Ident {
|
||||||
|
Ident::new(name, proc_macro2::Span::call_site())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create a path type from the given segments. For example an iterator yielding
|
||||||
|
/// the idents `[foo, bar, baz]` will result in the path type `foo::bar::baz`.
|
||||||
|
pub fn simple_path_ty<I>(segments: I) -> syn::Type
|
||||||
|
where
|
||||||
|
I: IntoIterator<Item = Ident>,
|
||||||
|
{
|
||||||
|
path_ty(false, segments)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create a global path type from the given segments. For example an iterator
|
||||||
|
/// yielding the idents `[foo, bar, baz]` will result in the path type
|
||||||
|
/// `::foo::bar::baz`.
|
||||||
|
pub fn leading_colon_path_ty<I>(segments: I) -> syn::Type
|
||||||
|
where
|
||||||
|
I: IntoIterator<Item = Ident>,
|
||||||
|
{
|
||||||
|
path_ty(true, segments)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn path_ty<I>(leading_colon: bool, segments: I) -> syn::Type
|
||||||
|
where
|
||||||
|
I: IntoIterator<Item = Ident>,
|
||||||
|
{
|
||||||
|
let segments: Vec<_> = segments
|
||||||
|
.into_iter()
|
||||||
|
.map(|i| syn::PathSegment {
|
||||||
|
ident: i,
|
||||||
|
arguments: syn::PathArguments::None,
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
syn::TypePath {
|
||||||
|
qself: None,
|
||||||
|
path: syn::Path {
|
||||||
|
leading_colon: if leading_colon {
|
||||||
|
Some(Default::default())
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
},
|
||||||
|
segments: syn::punctuated::Punctuated::from_iter(segments),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
.into()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create a path type with a single segment from a given Identifier
|
||||||
|
pub fn ident_ty(ident: Ident) -> syn::Type {
|
||||||
|
simple_path_ty(Some(ident))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert an ImportFunction into the more generic Import type, wrapping the provided function
|
||||||
|
pub fn wrap_import_function(function: ast::ImportFunction) -> ast::Import {
|
||||||
|
ast::Import {
|
||||||
|
module: None,
|
||||||
|
js_namespace: None,
|
||||||
|
kind: ast::ImportKind::Function(function),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Small utility used when generating symbol names.
|
||||||
|
///
|
||||||
|
/// Hashes the public field here along with a few cargo-set env vars to
|
||||||
|
/// distinguish between runs of the procedural macro.
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct ShortHash<T>(pub T);
|
||||||
|
|
||||||
|
impl<T: Hash> fmt::Display for ShortHash<T> {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
static HASHED: AtomicBool = AtomicBool::new(false);
|
||||||
|
static HASH: AtomicUsize = AtomicUsize::new(0);
|
||||||
|
|
||||||
|
// Try to amortize the cost of loading env vars a lot as we're gonna be
|
||||||
|
// hashing for a lot of symbols.
|
||||||
|
if !HASHED.load(SeqCst) {
|
||||||
|
let mut h = DefaultHasher::new();
|
||||||
|
env::var("CARGO_PKG_NAME")
|
||||||
|
.expect("should have CARGO_PKG_NAME env var")
|
||||||
|
.hash(&mut h);
|
||||||
|
env::var("CARGO_PKG_VERSION")
|
||||||
|
.expect("should have CARGO_PKG_VERSION env var")
|
||||||
|
.hash(&mut h);
|
||||||
|
// This may chop off 32 bits on 32-bit platforms, but that's ok, we
|
||||||
|
// just want something to mix in below anyway.
|
||||||
|
HASH.store(h.finish() as usize, SeqCst);
|
||||||
|
HASHED.store(true, SeqCst);
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut h = DefaultHasher::new();
|
||||||
|
HASH.load(SeqCst).hash(&mut h);
|
||||||
|
self.0.hash(&mut h);
|
||||||
|
write!(f, "{:016x}", h.finish())
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue