From 3e6872f285fcce656f92693c728728d0a2275cb1 Mon Sep 17 00:00:00 2001 From: Pistonight Date: Mon, 9 Oct 2023 19:26:09 -0700 Subject: [PATCH 1/4] compiler-macros project --- compiler-macros/Cargo.toml | 14 ++++++++++++ compiler-macros/src/lib.rs | 46 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 compiler-macros/Cargo.toml create mode 100644 compiler-macros/src/lib.rs diff --git a/compiler-macros/Cargo.toml b/compiler-macros/Cargo.toml new file mode 100644 index 00000000..02fedeaa --- /dev/null +++ b/compiler-macros/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "compiler-macros" +version = "0.0.0" +description = "(Proc) Macros for the compiler core" +edition = "2021" + +[dependencies] +proc-macro2 = "1.0.69" +quote = "1.0.33" + +[lib] +proc-macro = true +name = "celercmacros" +path = "src/lib.rs" diff --git a/compiler-macros/src/lib.rs b/compiler-macros/src/lib.rs new file mode 100644 index 00000000..3260cdbc --- /dev/null +++ b/compiler-macros/src/lib.rs @@ -0,0 +1,46 @@ +use quote::quote; +use proc_macro2::TokenStream; + +/// A wrapper to add Send trait to `async_trait` and `async_recursion` based on the `no-async-send` +/// feature gate +/// +/// # Examples +/// Instead of +/// ```ignore +/// #[async_trait] +/// pub trait XXX { +/// ... +/// } +/// ``` +/// Do +/// ```ignore +/// #[maybe_send(async_trait)] +/// pub trait XXX { +/// ... +/// } +/// ``` +/// Instead of +/// ```ignore +/// #[async_recursion] +/// pub async fn foo() { +/// ... +/// } +/// ``` +/// Do +/// ```ignore +/// #[maybe_send(async_recursion)] +/// pub async fn foo() { +/// ... +/// } +/// ``` +#[proc_macro_attribute] +pub fn maybe_send(attr: proc_macro::TokenStream, input: proc_macro::TokenStream) -> proc_macro::TokenStream { + let attr = TokenStream::from(attr); + let input = TokenStream::from(input); + let tokens = quote! { + #[cfg_attr(not(feature="no-async-send"), #attr)] + #[cfg_attr(feature="no-async-send", #attr(?Send))] + #input + }; + return tokens.into(); +} From 21101d4a2f4f5546e5d234ebec8dabd9c9af6c8a Mon Sep 17 00:00:00 2001 From: Pistonight Date: Mon, 9 Oct 2023 19:48:27 -0700 Subject: [PATCH 2/4] switch cfg_attrs to use maybe_send macro --- Cargo.lock | 18 +++++++++++++----- Cargo.toml | 1 + compiler-core/Cargo.toml | 3 +++ compiler-core/src/comp/comp_preset.rs | 4 ++-- compiler-core/src/lang/preset/blob.rs | 4 ++-- compiler-core/src/lang/preset/hydrate.rs | 5 +++-- compiler-core/src/lib.rs | 7 +++++++ compiler-core/src/pack/mod.rs | 4 ++-- compiler-core/src/pack/pack_preset.rs | 4 ++-- compiler-core/src/pack/pack_route.rs | 4 ++-- compiler-core/src/pack/resource/loader.rs | 4 ++-- .../src/pack/resource/loader_cache.rs | 5 +++-- .../src/pack/resource/loader_empty.rs | 4 ++-- .../src/pack/resource/resource_github.rs | 6 +++--- .../src/pack/resource/resource_impl.rs | 12 ++++++------ .../src/pack/resource/resource_local.rs | 4 ++-- compiler-wasm/Cargo.toml | 1 - compiler-wasm/src/loader_cache.rs | 4 ++-- compiler-wasm/src/loader_file.rs | 3 ++- compiler-wasm/src/loader_url.rs | 3 ++- 20 files changed, 61 insertions(+), 39 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f537dcff..1f646cb9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -338,6 +338,7 @@ dependencies = [ "async-recursion", "async-trait", "cached", + "compiler-macros", "compiler-types", "derivative", "futures", @@ -356,6 +357,14 @@ dependencies = [ "web-sys", ] +[[package]] +name = "compiler-macros" +version = "0.0.0" +dependencies = [ + "proc-macro2", + "quote", +] + [[package]] name = "compiler-types" version = "0.0.0" @@ -368,7 +377,6 @@ dependencies = [ name = "compiler-wasm" version = "0.0.0" dependencies = [ - "async-trait", "base64", "compiler-core", "compiler-types", @@ -997,18 +1005,18 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] name = "proc-macro2" -version = "1.0.67" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328" +checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.32" +version = "1.0.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50f3b39ccfb720540debaa0164757101c08ecb8d326b15358ce76a62c7e85965" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" dependencies = [ "proc-macro2", ] diff --git a/Cargo.toml b/Cargo.toml index db5203ec..0fbaff1b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,6 +2,7 @@ resolver = "2" members = [ "compiler-core/", + "compiler-macros/", "compiler-types/", "compiler-wasm/", "web-server/", diff --git a/compiler-core/Cargo.toml b/compiler-core/Cargo.toml index ee0d644d..785f36fb 100644 --- a/compiler-core/Cargo.toml +++ b/compiler-core/Cargo.toml @@ -8,6 +8,7 @@ edition = "2021" async-recursion = "1.0.4" async-trait = "0.1.73" cached = { version = "0.45.1", features = ["async"]} +compiler-macros = { path = "../compiler-macros" } compiler-types = { path = "../compiler-types" } derivative = "2.2.0" futures = "0.3.28" @@ -41,7 +42,9 @@ wasm = [ "js-sys", "web-sys/Window", "instant/wasm-bindgen", + "no-async-send", ] +no-async-send=[] [lib] name = "celerc" diff --git a/compiler-core/src/comp/comp_preset.rs b/compiler-core/src/comp/comp_preset.rs index edce6c79..3ea86e2e 100644 --- a/compiler-core/src/comp/comp_preset.rs +++ b/compiler-core/src/comp/comp_preset.rs @@ -4,6 +4,7 @@ use serde_json::Value; use crate::json::{Cast, Coerce}; use crate::lang::PresetInst; +use crate::macros::{async_recursion, maybe_send}; use crate::prop; use super::{validate_not_array_or_object, Compiler, CompilerError}; @@ -12,8 +13,7 @@ impl Compiler { /// Apply the preset to the output. /// /// Presets are applied recursively, including presets in the movements - #[cfg_attr(not(feature = "wasm"), async_recursion::async_recursion)] - #[cfg_attr(feature = "wasm", async_recursion::async_recursion(?Send))] + #[maybe_send(async_recursion)] pub async fn apply_preset( &self, depth: usize, diff --git a/compiler-core/src/lang/preset/blob.rs b/compiler-core/src/lang/preset/blob.rs index 4a9b22d8..42de25ee 100644 --- a/compiler-core/src/lang/preset/blob.rs +++ b/compiler-core/src/lang/preset/blob.rs @@ -3,6 +3,7 @@ use std::collections::BTreeMap; use serde_json::Value; use crate::lang::TempStr; +use crate::macros::{maybe_send, async_recursion}; use super::{Preset, PresetBlob}; @@ -37,8 +38,7 @@ impl PresetBlob { /// If the blob has any template strings in it, returns a Some variant with /// the template strings compiled and the input value taken out. /// Otherwise returns a None variant. - #[cfg_attr(not(feature = "wasm"), async_recursion::async_recursion)] - #[cfg_attr(feature = "wasm", async_recursion::async_recursion(?Send))] + #[maybe_send(async_recursion)] async fn compile_internal(value: &mut Value) -> Option { match value { Value::String(s) => { diff --git a/compiler-core/src/lang/preset/hydrate.rs b/compiler-core/src/lang/preset/hydrate.rs index 0f237755..991f25bc 100644 --- a/compiler-core/src/lang/preset/hydrate.rs +++ b/compiler-core/src/lang/preset/hydrate.rs @@ -2,6 +2,8 @@ use std::collections::BTreeMap; use serde_json::{json, Value}; +use crate::macros::{maybe_send, async_recursion}; + use super::{Preset, PresetBlob}; impl Preset { @@ -22,8 +24,7 @@ impl Preset { impl PresetBlob { /// Hydrate a preset blob with the given arguments - #[cfg_attr(not(feature = "wasm"), async_recursion::async_recursion)] - #[cfg_attr(feature = "wasm", async_recursion::async_recursion(?Send))] + #[maybe_send(async_recursion)] pub async fn hydrate(&self, args: &[S]) -> Value where S: AsRef + Sync, diff --git a/compiler-core/src/lib.rs b/compiler-core/src/lib.rs index c1844b00..a3f5f937 100644 --- a/compiler-core/src/lib.rs +++ b/compiler-core/src/lib.rs @@ -9,3 +9,10 @@ pub mod plug; pub mod metrics; pub mod prop; pub mod util; + +/// Re-exports of macros +pub mod macros { + pub use celercmacros::maybe_send; + pub use async_recursion::async_recursion; + pub use async_trait::async_trait; +} diff --git a/compiler-core/src/pack/mod.rs b/compiler-core/src/pack/mod.rs index 50e55729..4af5f995 100644 --- a/compiler-core/src/pack/mod.rs +++ b/compiler-core/src/pack/mod.rs @@ -34,6 +34,7 @@ pub use resource::*; use crate::json::Cast; use crate::lang::parse_poor; +use crate::macros::{async_recursion, maybe_send}; #[derive(Debug, Clone, PartialEq, thiserror::Error, Serialize, Deserialize)] #[serde(rename_all = "camelCase", tag = "type", content = "data")] @@ -230,8 +231,7 @@ impl PackerValue { } } - #[cfg_attr(not(feature = "wasm"), async_recursion::async_recursion)] - #[cfg_attr(feature = "wasm", async_recursion::async_recursion(?Send))] + #[maybe_send(async_recursion)] async fn flatten_internal(self, output_errors: &mut Vec) -> Option { match self { Self::Ok(x) => Some(x), diff --git a/compiler-core/src/pack/pack_preset.rs b/compiler-core/src/pack/pack_preset.rs index ba9e67cd..9989399a 100644 --- a/compiler-core/src/pack/pack_preset.rs +++ b/compiler-core/src/pack/pack_preset.rs @@ -5,6 +5,7 @@ use serde_json::Value; use crate::json::Cast; use crate::lang::Preset; +use crate::macros::{async_recursion, maybe_send}; use crate::prop; use crate::util::async_for; @@ -20,8 +21,7 @@ pub async fn pack_presets( Ok(output) } -#[cfg_attr(not(feature = "wasm"), async_recursion::async_recursion)] -#[cfg_attr(feature = "wasm", async_recursion::async_recursion(?Send))] +#[maybe_send(async_recursion)] async fn pack_presets_internal( preset_name: &str, value: Value, diff --git a/compiler-core/src/pack/pack_route.rs b/compiler-core/src/pack/pack_route.rs index f4dc4ced..d797421c 100644 --- a/compiler-core/src/pack/pack_route.rs +++ b/compiler-core/src/pack/pack_route.rs @@ -7,6 +7,7 @@ use std::collections::BTreeMap; use serde_json::Value; use crate::json::Cast; +use crate::macros::{async_recursion, maybe_send}; use crate::util::async_for; use super::{PackerError, PackerValue, Resource, Use, ValidUse}; @@ -29,8 +30,7 @@ pub async fn pack_route( } /// Pack a portion of the route -#[cfg_attr(not(feature = "wasm"), async_recursion::async_recursion)] -#[cfg_attr(feature = "wasm", async_recursion::async_recursion(?Send))] +#[maybe_send(async_recursion)] async fn pack_route_internal( // The resource that contains the route resource: &Resource, diff --git a/compiler-core/src/pack/resource/loader.rs b/compiler-core/src/pack/resource/loader.rs index d93af3e0..e4070c30 100644 --- a/compiler-core/src/pack/resource/loader.rs +++ b/compiler-core/src/pack/resource/loader.rs @@ -1,10 +1,10 @@ use serde_json::Value; +use crate::macros::{async_trait, maybe_send}; use crate::pack::{PackerError, PackerResult}; /// Loader that loads resources from external place -#[cfg_attr(not(feature = "wasm"), async_trait::async_trait)] -#[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))] +#[maybe_send(async_trait)] pub trait ResourceLoader { /// Load a resource as raw bytes async fn load_raw(&self, path: &str) -> PackerResult>; diff --git a/compiler-core/src/pack/resource/loader_cache.rs b/compiler-core/src/pack/resource/loader_cache.rs index df5e3491..b238c917 100644 --- a/compiler-core/src/pack/resource/loader_cache.rs +++ b/compiler-core/src/pack/resource/loader_cache.rs @@ -1,6 +1,8 @@ +/// currently unused. implementation kept for reference use cached::proc_macro::cached; use serde_json::Value; +use crate::macros::{async_recursion, maybe_send}; use crate::pack::PackerResult; use super::{ArcLoader, ResourceLoader}; @@ -16,8 +18,7 @@ impl GlobalCacheLoader { } } -#[cfg_attr(not(feature = "wasm"), async_trait::async_trait)] -#[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))] +#[maybe_send(async_trait)] impl ResourceLoader for GlobalCacheLoader where L: ResourceLoader { async fn load_raw(&self, r: &str) -> PackerResult> { load_raw_internal(&self.delegate, r).await diff --git a/compiler-core/src/pack/resource/loader_empty.rs b/compiler-core/src/pack/resource/loader_empty.rs index b31486a0..5fea2b5c 100644 --- a/compiler-core/src/pack/resource/loader_empty.rs +++ b/compiler-core/src/pack/resource/loader_empty.rs @@ -1,3 +1,4 @@ +use crate::macros::{async_trait, maybe_send}; use crate::pack::{PackerError, PackerResult}; use super::ResourceLoader; @@ -13,8 +14,7 @@ impl EmptyLoader { } } -#[cfg_attr(not(feature = "wasm"), async_trait::async_trait)] -#[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))] +#[maybe_send(async_trait)] impl ResourceLoader for EmptyLoader { async fn load_raw(&self, _: &str) -> PackerResult> { Err(Self::throw()) diff --git a/compiler-core/src/pack/resource/resource_github.rs b/compiler-core/src/pack/resource/resource_github.rs index 16660d1e..aa4d6c25 100644 --- a/compiler-core/src/pack/resource/resource_github.rs +++ b/compiler-core/src/pack/resource/resource_github.rs @@ -1,10 +1,11 @@ //! GitHub resource resolver and loader impl use std::sync::Arc; +use crate::macros::{maybe_send, async_trait}; use crate::util::Path; +use crate::pack::{PackerError, PackerResult, ValidUse}; use super::{ArcLoader, EmptyLoader, Resource, ResourcePath, ResourceResolver}; -use crate::pack::{PackerError, PackerResult, ValidUse}; pub struct GitHubResourceResolver { owner: String, @@ -24,8 +25,7 @@ impl GitHubResourceResolver { } } -#[cfg_attr(not(feature = "wasm"), async_trait::async_trait)] -#[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))] +#[maybe_send(async_trait)] impl ResourceResolver for GitHubResourceResolver { async fn resolve(&self, source: &Resource, target: &ValidUse) -> PackerResult { match target { diff --git a/compiler-core/src/pack/resource/resource_impl.rs b/compiler-core/src/pack/resource/resource_impl.rs index 2255f5aa..1808fcad 100644 --- a/compiler-core/src/pack/resource/resource_impl.rs +++ b/compiler-core/src/pack/resource/resource_impl.rs @@ -3,17 +3,18 @@ use std::sync::Arc; use serde_json::Value; use crate::pack::{PackerResult, ValidUse}; +use crate::macros::{maybe_send, async_trait}; use crate::util::Path; use super::ResourceLoader; -#[cfg(not(feature = "wasm"))] +#[cfg(not(feature = "no-async-send"))] pub type ArcLoader = Arc; -#[cfg(not(feature = "wasm"))] +#[cfg(not(feature = "no-async-send"))] pub type ArcResolver = Arc; -#[cfg(feature = "wasm")] +#[cfg(feature = "no-async-send")] pub type ArcLoader = Arc; -#[cfg(feature = "wasm")] +#[cfg(feature = "no-async-send")] pub type ArcResolver = Arc; macro_rules! loader_delegate { @@ -81,8 +82,7 @@ impl Resource { } } -#[cfg_attr(not(feature = "wasm"), async_trait::async_trait)] -#[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))] +#[maybe_send(async_trait)] pub trait ResourceResolver { /// Resolve a resource from the given `Use` and loader async fn resolve(&self, source: &Resource, target: &ValidUse) -> PackerResult; diff --git a/compiler-core/src/pack/resource/resource_local.rs b/compiler-core/src/pack/resource/resource_local.rs index 466d95ac..d2714460 100644 --- a/compiler-core/src/pack/resource/resource_local.rs +++ b/compiler-core/src/pack/resource/resource_local.rs @@ -1,5 +1,6 @@ use std::sync::Arc; +use crate::macros::{maybe_send, async_trait}; use crate::pack::{PackerError, PackerResult, ValidUse}; use crate::util::Path; @@ -7,8 +8,7 @@ use super::{create_github_resource_from, Resource, ResourcePath, ResourceResolve pub struct LocalResourceResolver(pub Path); -#[cfg_attr(not(feature = "wasm"), async_trait::async_trait)] -#[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))] +#[maybe_send(async_trait)] impl ResourceResolver for LocalResourceResolver { async fn resolve(&self, source: &Resource, target: &ValidUse) -> PackerResult { match target { diff --git a/compiler-wasm/Cargo.toml b/compiler-wasm/Cargo.toml index f77e27d9..a7c4af12 100644 --- a/compiler-wasm/Cargo.toml +++ b/compiler-wasm/Cargo.toml @@ -14,7 +14,6 @@ serde-wasm-bindgen = "0.5.0" wasm-bindgen = "0.2.87" wasm-bindgen-futures = "0.4.37" js-sys = "0.3.64" -async-trait = "0.1.73" log = { version = "0.4.20", features = ["std"] } web-sys = { version = "0.3.64", features = ["console", "Location", "Window"] } base64 = "0.21.4" diff --git a/compiler-wasm/src/loader_cache.rs b/compiler-wasm/src/loader_cache.rs index 4585eeed..d10a6ac4 100644 --- a/compiler-wasm/src/loader_cache.rs +++ b/compiler-wasm/src/loader_cache.rs @@ -3,9 +3,9 @@ use cached::proc_macro::cached; use serde_json::Value; +use celerc::macros::async_trait; use celerc::pack::{ ResourceLoader, PackerResult}; - /// A loader that caches loaded JSON object in memory to skip parsing. The cache is global. pub struct CachedLoader { delegate: L, @@ -21,7 +21,7 @@ impl CachedLoader { } } -#[async_trait::async_trait(?Send)] +#[async_trait(?Send)] impl ResourceLoader for CachedLoader where L: ResourceLoader { async fn load_raw(&self, r: &str) -> PackerResult> { self.delegate.load_raw(r).await diff --git a/compiler-wasm/src/loader_file.rs b/compiler-wasm/src/loader_file.rs index b1ceaab0..c06e1850 100644 --- a/compiler-wasm/src/loader_file.rs +++ b/compiler-wasm/src/loader_file.rs @@ -4,6 +4,7 @@ use base64::Engine; use std::cell::RefCell; use celerc::pack::{ImageFormat, PackerError, PackerResult, ResourceLoader}; +use celerc::macros::async_trait; use celerc::yield_now; use js_sys::{Function, Uint8Array}; use wasm_bindgen::{JsCast, JsValue}; @@ -30,7 +31,7 @@ impl FileLoader { } } -#[async_trait::async_trait(?Send)] +#[async_trait(?Send)] impl ResourceLoader for FileLoader { async fn load_raw(&self, path: &str) -> PackerResult> { let _ = yield_now!(); diff --git a/compiler-wasm/src/loader_url.rs b/compiler-wasm/src/loader_url.rs index 2c34dc34..da4cb479 100644 --- a/compiler-wasm/src/loader_url.rs +++ b/compiler-wasm/src/loader_url.rs @@ -1,6 +1,7 @@ use std::cell::RefCell; use celerc::pack::{PackerError, PackerResult, ResourceLoader}; +use celerc::macros::async_trait; use celerc::yield_now; use js_sys::{Function, Uint8Array}; use wasm_bindgen::{JsCast, JsValue}; @@ -27,7 +28,7 @@ impl UrlLoader { } } -#[async_trait::async_trait(?Send)] +#[async_trait(?Send)] impl ResourceLoader for UrlLoader { async fn load_raw(&self, url: &str) -> PackerResult> { let _ = yield_now!(); From dd472f7a2921acf1e4e272a93477efc1513ed5a6 Mon Sep 17 00:00:00 2001 From: Pistonight Date: Mon, 9 Oct 2023 19:50:12 -0700 Subject: [PATCH 3/4] run fmt --- compiler-core/src/lang/preset/blob.rs | 2 +- compiler-core/src/lang/preset/hydrate.rs | 2 +- compiler-core/src/lib.rs | 2 +- compiler-core/src/pack/resource/resource_github.rs | 4 ++-- compiler-core/src/pack/resource/resource_impl.rs | 2 +- compiler-core/src/pack/resource/resource_local.rs | 2 +- compiler-macros/src/lib.rs | 11 +++++++---- compiler-wasm/src/loader_file.rs | 2 +- compiler-wasm/src/loader_url.rs | 2 +- 9 files changed, 16 insertions(+), 13 deletions(-) diff --git a/compiler-core/src/lang/preset/blob.rs b/compiler-core/src/lang/preset/blob.rs index 42de25ee..85873040 100644 --- a/compiler-core/src/lang/preset/blob.rs +++ b/compiler-core/src/lang/preset/blob.rs @@ -3,7 +3,7 @@ use std::collections::BTreeMap; use serde_json::Value; use crate::lang::TempStr; -use crate::macros::{maybe_send, async_recursion}; +use crate::macros::{async_recursion, maybe_send}; use super::{Preset, PresetBlob}; diff --git a/compiler-core/src/lang/preset/hydrate.rs b/compiler-core/src/lang/preset/hydrate.rs index 991f25bc..a43bafa5 100644 --- a/compiler-core/src/lang/preset/hydrate.rs +++ b/compiler-core/src/lang/preset/hydrate.rs @@ -2,7 +2,7 @@ use std::collections::BTreeMap; use serde_json::{json, Value}; -use crate::macros::{maybe_send, async_recursion}; +use crate::macros::{async_recursion, maybe_send}; use super::{Preset, PresetBlob}; diff --git a/compiler-core/src/lib.rs b/compiler-core/src/lib.rs index a3f5f937..2ac8a51f 100644 --- a/compiler-core/src/lib.rs +++ b/compiler-core/src/lib.rs @@ -12,7 +12,7 @@ pub mod util; /// Re-exports of macros pub mod macros { - pub use celercmacros::maybe_send; pub use async_recursion::async_recursion; pub use async_trait::async_trait; + pub use celercmacros::maybe_send; } diff --git a/compiler-core/src/pack/resource/resource_github.rs b/compiler-core/src/pack/resource/resource_github.rs index aa4d6c25..0d33af55 100644 --- a/compiler-core/src/pack/resource/resource_github.rs +++ b/compiler-core/src/pack/resource/resource_github.rs @@ -1,9 +1,9 @@ //! GitHub resource resolver and loader impl use std::sync::Arc; -use crate::macros::{maybe_send, async_trait}; -use crate::util::Path; +use crate::macros::{async_trait, maybe_send}; use crate::pack::{PackerError, PackerResult, ValidUse}; +use crate::util::Path; use super::{ArcLoader, EmptyLoader, Resource, ResourcePath, ResourceResolver}; diff --git a/compiler-core/src/pack/resource/resource_impl.rs b/compiler-core/src/pack/resource/resource_impl.rs index 1808fcad..54e05529 100644 --- a/compiler-core/src/pack/resource/resource_impl.rs +++ b/compiler-core/src/pack/resource/resource_impl.rs @@ -2,8 +2,8 @@ use std::sync::Arc; use serde_json::Value; +use crate::macros::{async_trait, maybe_send}; use crate::pack::{PackerResult, ValidUse}; -use crate::macros::{maybe_send, async_trait}; use crate::util::Path; use super::ResourceLoader; diff --git a/compiler-core/src/pack/resource/resource_local.rs b/compiler-core/src/pack/resource/resource_local.rs index d2714460..a6b26d0b 100644 --- a/compiler-core/src/pack/resource/resource_local.rs +++ b/compiler-core/src/pack/resource/resource_local.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use crate::macros::{maybe_send, async_trait}; +use crate::macros::{async_trait, maybe_send}; use crate::pack::{PackerError, PackerResult, ValidUse}; use crate::util::Path; diff --git a/compiler-macros/src/lib.rs b/compiler-macros/src/lib.rs index 3260cdbc..cbad1374 100644 --- a/compiler-macros/src/lib.rs +++ b/compiler-macros/src/lib.rs @@ -1,11 +1,11 @@ -use quote::quote; use proc_macro2::TokenStream; +use quote::quote; /// A wrapper to add Send trait to `async_trait` and `async_recursion` based on the `no-async-send` /// feature gate /// /// # Examples -/// Instead of +/// Instead of /// ```ignore /// #[async_trait] /// pub trait XXX { @@ -19,7 +19,7 @@ use proc_macro2::TokenStream; /// ... /// } /// ``` -/// Instead of +/// Instead of /// ```ignore /// #[async_recursion] /// pub async fn foo() { @@ -34,7 +34,10 @@ use proc_macro2::TokenStream; /// } /// ``` #[proc_macro_attribute] -pub fn maybe_send(attr: proc_macro::TokenStream, input: proc_macro::TokenStream) -> proc_macro::TokenStream { +pub fn maybe_send( + attr: proc_macro::TokenStream, + input: proc_macro::TokenStream, +) -> proc_macro::TokenStream { let attr = TokenStream::from(attr); let input = TokenStream::from(input); let tokens = quote! { diff --git a/compiler-wasm/src/loader_file.rs b/compiler-wasm/src/loader_file.rs index c06e1850..b34493e4 100644 --- a/compiler-wasm/src/loader_file.rs +++ b/compiler-wasm/src/loader_file.rs @@ -3,8 +3,8 @@ use base64::engine::general_purpose; use base64::Engine; use std::cell::RefCell; -use celerc::pack::{ImageFormat, PackerError, PackerResult, ResourceLoader}; use celerc::macros::async_trait; +use celerc::pack::{ImageFormat, PackerError, PackerResult, ResourceLoader}; use celerc::yield_now; use js_sys::{Function, Uint8Array}; use wasm_bindgen::{JsCast, JsValue}; diff --git a/compiler-wasm/src/loader_url.rs b/compiler-wasm/src/loader_url.rs index da4cb479..0045a812 100644 --- a/compiler-wasm/src/loader_url.rs +++ b/compiler-wasm/src/loader_url.rs @@ -1,7 +1,7 @@ use std::cell::RefCell; -use celerc::pack::{PackerError, PackerResult, ResourceLoader}; use celerc::macros::async_trait; +use celerc::pack::{PackerError, PackerResult, ResourceLoader}; use celerc::yield_now; use js_sys::{Function, Uint8Array}; use wasm_bindgen::{JsCast, JsValue}; From d4fd705c2e78999a3d32f9ccd7c067845fc17c9e Mon Sep 17 00:00:00 2001 From: Pistonight Date: Mon, 9 Oct 2023 19:51:48 -0700 Subject: [PATCH 4/4] fix clippy --- compiler-macros/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler-macros/src/lib.rs b/compiler-macros/src/lib.rs index cbad1374..bdf641f0 100644 --- a/compiler-macros/src/lib.rs +++ b/compiler-macros/src/lib.rs @@ -45,5 +45,5 @@ pub fn maybe_send( #[cfg_attr(feature="no-async-send", #attr(?Send))] #input }; - return tokens.into(); + tokens.into() }