Add restriction and cargo

Author: mveril

Cargo.toml

@@ -22,19 +22,52 @@ description = "A Rust framework for developing WSL plugins using safe and idioma
 [patch.crates-io]
 wslpluginapi-sys = { version = "0.1.0-rc.1", git = "https://github.com/mveril/wslpluginapi-sys.git", branch = "develop" }
 
+
 [workspace.lints.rust]
-missing_docs = "warn"
-missing_errors_doc = "warn"
-missing_panics_doc = "warn"
-pub_use_of_private_imports = "allow"
+unused = "warn"
+future_incompatible = "deny"
 
 [workspace.lints.clippy]
-all = "warn"
+all = { level = "warn", priority = -1 }
 pedantic = { level = "warn", priority = -1 }
 nursery = { level = "warn", priority = -1 }
-# useful lib lints
+cargo = {level = "warn", priority = -1}
+# Enable some restriction
 needless_pass_by_value = "warn"
 implicit_clone = "warn"
 unnecessary_wraps = "warn"
-unwrap_used = "warn"
-expect_used = "warn"
+missing_const_for_fn = "warn"
+missing_inline_in_public_items = "warn"
+unnecessary_safety_doc = "deny"
+
+# ---- Strong DENY (CI-breaking, catch critical bugs) ----
+unwrap_used = "deny"                      # Avoid panics in production.
+expect_used = "deny"                      # Same as unwrap, no `.expect`.
+panic = "deny"                            # No panic! in library code.
+todo = "deny"                             # No todo! in shipped code.
+print_stdout = "deny"                     # Use logging, not println.
+print_stderr = "deny"                     # Use logging, not eprintln.
+dbg_macro = "deny"                        # No dbg! in release builds.
+mem_forget = "deny"                       # Prevent memory leaks.
+await_holding_lock = "deny"               # Prevent async deadlocks with held locks.
+exit = "deny"                             # Libraries must not kill the process.
+
+# ---- Useful WARN (signal, but not blocking) ----
+undocumented_unsafe_blocks = "warn"       # Every unsafe block must be justified with SAFETY.
+missing_assert_message = "warn"           # Clear messages for all asserts.
+integer_division = "warn"                 # Be explicit about truncating integer division.
+indexing_slicing = "warn"                 # Can panic if index is wrong.
+float_arithmetic = "warn"                 # Flag nondeterministic floating arithmetic.
+mutable_key_type = "warn"                 # Prevent mutable keys in maps (subtle bugs).
+manual_non_exhaustive = "warn"            # Use #[non_exhaustive] instead of manual tricks.
+wrong_self_convention = "warn"            # Enforce idiomatic naming for as_/to_/into_ methods.
+rc_mutex = "warn" 
+use_debug = "warn"
+
+[workspace.lints.rustdoc]
+all = "warn"
+broken_intra_doc_links = "forbid"
+private_intra_doc_links = "deny"
+invalid_rust_codeblocks = "deny"
+bare_urls = "warn"
+missing_crate_level_docs = "warn"

wslplugins-macro-core/Cargo.toml

@@ -5,6 +5,9 @@ version.workspace = true
 license.workspace = true
 repository.workspace = true
 edition = "2021"
+description = "internal core implementation of for wslplugins-macro"
+keywords = ["wsl", "plugin", "windows", "linux", "internal"]
+categories = ["os::windows-apis", "api-bindings", "virtualization"]
 
 [dependencies]
 syn = { version = "*", features = ["full", "extra-traits"] }

wslplugins-macro-core/README.md

@@ -0,0 +1,2 @@
+# wslplugins-macro-core
+This package is a dependency of `wslplugins-macro` and provide the core of the macro logic it not intended to be installed manually

wslplugins-macro-core/build.rs

@@ -1,6 +1,6 @@
 #![allow(missing_docs)]
-use std::{env, fs::File, io::Write, path::PathBuf};
-use struct_field_names_as_array::FieldNamesAsSlice;
+use std::{env, fs::File, io::Write as _, path::PathBuf};
+use struct_field_names_as_array::FieldNamesAsSlice as _;
 use wslpluginapi_sys::WSLPluginHooksV1;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {

wslplugins-macro-core/src/generator/c_funcs_tokens.rs

@@ -69,22 +69,7 @@ pub(super) fn get_c_func_tokens(hook: Hooks) -> Result<Option<TokenStream>> {
                 }).unwrap_or(::wslplugins_rs::sys::windows_sys::Win32::Foundation::E_FAIL)
             }
         }),
-        Hooks::OnDistributionRegistered => Some(quote! {
-            extern "C" fn #c_method_ident(
-                session: *const ::wslplugins_rs::sys::WSLSessionInformation,
-                distribution:  *const ::wslplugins_rs::sys::WSLOfflineDistributionInformation,
-            ) -> ::wslplugins_rs::sys::windows_sys::core::HRESULT {
-                let session_ptr = unsafe { &*session };
-                let distribution_ptr = unsafe { &*distribution };
-                PLUGIN.get().map(|plugin|{
-                    ::wslplugins_rs::windows_core::HRESULT::from(plugin.#trait_method_ident(
-                        session_ptr.as_ref(),
-                        distribution_ptr.as_ref(),
-                    )).0
-                }).unwrap_or(::wslplugins_rs::sys::windows_sys::Win32::Foundation)
-            }
-        }),
-        Hooks::OnDistributionUnregistered => Some(quote! {
+        Hooks::OnDistributionRegistered | Hooks::OnDistributionUnregistered => Some(quote! {
             extern "C" fn #c_method_ident(
                 session: *const ::wslplugins_rs::sys::WSLSessionInformation,
                 distribution:  *const ::wslplugins_rs::sys::WSLOfflineDistributionInformation,

wslplugins-macro-core/src/generator/hook_field_mapping.rs

@@ -32,7 +32,7 @@ fn generate_hook_fns(hooks: &[Hooks]) -> Result<Vec<TokenStream>> {
 }
 
 // Create a static version of the type for plugin management
-fn create_static_type(imp: &ParsedImpl) -> Result<Type> {
+fn create_static_type(imp: &ParsedImpl) -> Type {
     let mut static_type = imp.target_type.as_ref().clone();
     if let Some(lifetime) = utils::get_path_lifetime(&imp.trait_) {
         utils::replace_lifetime_in_type(
@@ -41,7 +41,7 @@ fn create_static_type(imp: &ParsedImpl) -> Result<Type> {
             &Lifetime::new("'static", Span::call_site()),
         );
     }
-    Ok(static_type)
+    static_type
 }
 
 // Prepare hooks by mapping them to their respective fields in the hook structure
@@ -83,7 +83,7 @@ fn hook_field_mapping(hooks_struct_name: &Ident, hook: Hooks) -> Result<TokenStr
 
 // Generate the plugin entry function with hook management and initialization
 fn generate_entry_point(imp: &ParsedImpl, version: &RequiredVersion) -> Result<TokenStream> {
-    let static_plugin_type = create_static_type(imp)?;
+    let static_plugin_type = create_static_type(imp);
     let hooks_ref_name = format_ident!("hooks_ref");
     let hook_set = prepare_hooks(&hooks_ref_name, &imp.hooks)?;
     let RequiredVersion {

wslplugins-macro-core/src/generator/mod.rs

@@ -1,4 +1,4 @@
 mod c_funcs_tokens;
 mod hook_field_mapping;
 mod utils;
-pub(crate) use hook_field_mapping::generate;
+pub use hook_field_mapping::generate;

wslplugins-macro-core/src/generator/utils.rs

@@ -1,4 +1,7 @@
-use syn::*;
+use syn::{
+    GenericArgument, Lifetime, Path, PathArguments, Type, TypeBareFn, TypePath, TypeReference,
+    TypeTuple,
+};
 
 pub(super) fn replace_lifetime_in_type(
     ty: &mut Type,

wslplugins-macro-core/src/hooks.rs

@@ -1,22 +1,22 @@
-use heck::ToSnakeCase;
-use strum::IntoEnumIterator;
+use heck::ToSnakeCase as _;
+use strum::IntoEnumIterator as _;
 include!(concat!(env!("OUT_DIR"), "/hooks.rs"));
 
 impl Hooks {
-    pub fn get_c_method_name(&self) -> String {
+    pub(crate) fn get_c_method_name(self) -> String {
         self.to_string().to_snake_case()
     }
 
-    pub fn get_hook_field_name(&self) -> String {
+    pub(crate) fn get_hook_field_name(self) -> String {
         self.to_string()
     }
 
-    pub fn get_trait_method_name(&self) -> String {
+    pub(crate) fn get_trait_method_name(self) -> String {
         self.to_string().to_snake_case()
     }
 
-    pub fn from_trait_method_name(trait_method_name: impl AsRef<str>) -> Option<Hooks> {
-        Hooks::iter().find(|hook| hook.get_trait_method_name() == trait_method_name.as_ref())
+    pub(crate) fn from_trait_method_name(trait_method_name: impl AsRef<str>) -> Option<Self> {
+        Self::iter().find(|hook| hook.get_trait_method_name() == trait_method_name.as_ref())
     }
 }
 

wslplugins-macro-core/src/lib.rs

@@ -1,6 +1,8 @@
-#![allow(missing_docs)]
-#![allow(rustdoc::missing_errors_doc)]
-#![allow(rustdoc::missing_panics_doc)]
+#![allow(rustdoc::missing_doc)]
+#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::missing_panics_doc)]
+#![allow(clippy::panic)]
+#![allow(clippy::panic_in_result_fn)]
 mod generator;
 mod hooks;
 mod parser;
@@ -12,8 +14,8 @@ use quote::quote;
 use syn::{parse2, Result};
 
 use crate::parser::{ParsedImpl, RequiredVersion};
-
-pub fn wsl_plugin_v1(attr: TokenStream, item: TokenStream) -> Result<TokenStream> {
+#[inline]
+pub fn wsl_plugin_v1(attr: TokenStream, item: &TokenStream) -> Result<TokenStream> {
     let parsed_impl_result = parse2::<ParsedImpl>(item.clone());
     let required_version_result = parse2::<RequiredVersion>(attr);
     let (parsed_impl, required_version) =