linted -> back to: frontend; unlinted -> back to: backend

Author: peter-lyons-kehl

src/unlinted.rs src/backend.rssrc/unlinted.rs renamed to src/backend.rs

@@ -1,4 +1,4 @@
-//! "Unlinted" functionality (anything else than linted macros)
+//! "backend" functionality (anything else than linted macros)
 //! - macros that don't need `warn/deny/forbid/allow/expect` lint rules
 //! - non-macro functionality.
 
@@ -281,7 +281,7 @@ pub mod expecting_unsafe_fn {
 #[doc(hidden)]
 macro_rules! expecting_unsafe_fn_path {
     ( $( $arg:expr ),+ ) => {
-        $crate::expecting_unsafe_fn_path!( ~ { $( $arg ),+ }, $crate::unlinted::expecting_unsafe_fn )
+        $crate::expecting_unsafe_fn_path!( ~ { $( $arg ),+ }, $crate::backend::expecting_unsafe_fn )
     };
     ( ~ { $arg_first:expr, $( $arg_rest:expr ),+ }, $( $path_part:tt )+ ) => {
         $crate::expecting_unsafe_fn_path!( ~ { $( $arg_rest ),+ }, $( $path_part )+ ::arg )

src/linted_loader.rs src/frontend_loader.rssrc/linted_loader.rs renamed to src/frontend_loader.rs

@@ -1,20 +1,20 @@
-// - Linted ("frontend"_ macros can (and do) invoke unlinted ("backend") macros, but not the other
-//   way. That's because unlinted macros don't know the crate name where linted macros were loaded.
-// - linted macros can be recursive (between themselves, but not through unlinted ("backend")
+// - Linted ("frontend"_ macros can (and do) invoke backend ("backend") macros, but not the other
+//   way. That's because backend macros don't know the crate name where linted macros were loaded.
+// - linted macros can be recursive (between themselves, but not through backend ("backend")
 //   macros")
 /// "Load" prudent macros. Invoke this from the top level of your crate, and only once (once per
 /// crate).
 #[macro_export]
 macro_rules! load {
     // No lints.
     //
-    // re-export all (both `linted` and `unlinted`) from `prudent` crate under module `prudent`.
+    // re-export all (both `linted` and `backend`) from `prudent` crate under module `prudent`.
     () => {
         $crate::load!( prudent );
     };
     // No lints.
     //
-    // re-export all (both `linted` and `unlinted`) from `prudent` crate, under given module name.
+    // re-export all (both `linted` and `backend`) from `prudent` crate, under given module name.
     ( $module_name:ident ) => {
         /// prudent exported in a module
         mod $module_name {
@@ -23,7 +23,7 @@ macro_rules! load {
         }
     };// -----------
 
-    // load `linted` from the given file; re-export `unlinted` from `prudent` crate; blend them
+    // load `linted` from the given file; re-export `backend` from `prudent` crate; blend them
     // under a module with the given name. If `$module_name` is not given, it's `prudent`.
     //
     // Since `any` is **not** specified, this applies to `$[cfg(test)` only.
@@ -122,7 +122,7 @@ macro_rules! load {
             $crate::reexport_non_macros!( super::internal_prudent_linted_loaded_or_aliased );
         }
         const _VERIFY_VERSION: () = {
-            ::prudent::unlinted::verify_linted_version( $module_name::PRUDENT_INTERNAL_LINTED_VERSION );
+            ::prudent::backend::verify_linted_version( $module_name::PRUDENT_INTERNAL_LINTED_VERSION );
         };
     }
 }
@@ -158,7 +158,7 @@ macro_rules! reexport_macros {
 
 /// Re-export
 /// 1. non-macros from the given `linted`_module/path. And
-/// 2. anything needed from `unlinted`.
+/// 2. anything needed from `backend`.
 ///
 /// NOT a part of public API - internal.
 #[doc(hidden)]
@@ -172,6 +172,6 @@ macro_rules! reexport_non_macros {
         pub use $linted_path::{PRUDENT_INTERNAL_LINTED_VERSION};
 
         #[allow(unused)]
-        pub use ::prudent::unlinted::*;
+        pub use ::prudent::backend::*;
     };
 }

src/linted_internal.rs src/frontend_unlinted.rssrc/linted_internal.rs renamed to src/frontend_unlinted.rs

@@ -3,7 +3,7 @@
 // https://github.com/prudent-rs/prudent/, https://crates.io/crates/prudent and
 // https://docs.rs/prudent/latest/prudent.
 
-// For docs see linted_with_tests.rs
+// For docs see frontend_with_tests.rs
 #![allow(missing_docs)]
 
 #[doc(hidden)]
@@ -17,7 +17,7 @@ const _VERIFY_MODULE_PATH: () = {
         [b'p', b'r', b'u', b'd', b'e', b'n', b't', b':', b':', ..]
     ) {
         panic!(
-            "Use ONLY linted.rs in your crate(s). Do not use linted_internal.rs, as that is internal."
+            "Use ONLY linted.rs in your crate(s). Do not use frontend_unlinted.rs, as that is internal."
         );
     }
 };
@@ -59,7 +59,7 @@ macro_rules! internal_prudent_unsafe_fn {
                 // block(s).
                 //
                 // The rest of this comment block/lines exists the same in both linted.rs and
-                // linted_internal.rs, but it applies to linted.rs ONLY.
+                // frontend_unlinted.rs, but it applies to linted.rs ONLY.
                 //
                 // (That minimizes the number of differences between those two files.)
                 //
@@ -113,7 +113,7 @@ macro_rules! internal_prudent_unsafe_fn {
                 // Ensure that $fn is not safe, but `unsafe`. Using
                 // https://doc.rust-lang.org/reference/types/function-item.html#r-type.fn-item.coercion
                 let _ = if false {
-                    ::prudent::unlinted::expecting_unsafe_fn::fun
+                    ::prudent::backend::expecting_unsafe_fn::fun
                 } else {
                     fun
                 };
@@ -271,7 +271,7 @@ macro_rules! internal_prudent_unsafe_method {
                             #[expect(unsafe_code)]
                         )?
                         let rref = &( $self );
-                        ::prudent::unlinted::shared_to_mut( rref )
+                        ::prudent::backend::shared_to_mut( rref )
                     };
                     #[allow(unused_mut)]
                     #[allow(invalid_value)]
@@ -510,13 +510,13 @@ pub use internal_prudent_unsafe_mut;
 macro_rules! internal_prudent_unsafe_val {
     ($ptr:expr) => {{
         let ptr: *const _ = $ptr;
-        ::prudent::unlinted::expect_copy_ptr(ptr);
+        ::prudent::backend::expect_copy_ptr(ptr);
         unsafe { *ptr }
     }};
     ($ptr:expr, $ptr_type:ty) => {{
         let ptr = $ptr;
         let ptr = ptr as *const $ptr_type;
-        ::prudent::unlinted::expect_copy_ptr(ptr);
+        ::prudent::backend::expect_copy_ptr(ptr);
         unsafe { *ptr }
     }};
 }

src/linted_with_tests.rs src/frontend_with_tests.rssrc/linted_with_tests.rs renamed to src/frontend_with_tests.rs

@@ -20,13 +20,15 @@ error: circular modules: src/internal_front_end.rs -> src/internal_front_end.rs
 const _VERIFY_MODULE_PATH: () = {
     let path = core::module_path!().as_bytes();
     if !matches!(path, b"prudent::linted") {
-        panic!("Do NOT load linted_with_tests.rs in other crates. It's internal in prudent only.");
+        panic!(
+            "Do NOT load frontend_with_tests.rs in other crates. It's internal in prudent only."
+        );
     }
 };
 
 #[doc(hidden)]
 #[allow(unused)]
-pub use crate::linted_untested::PRUDENT_INTERNAL_LINTED_VERSION;
+pub use crate::frontend_untested::PRUDENT_INTERNAL_LINTED_VERSION;
 
 /// ```compile_fail
 /// // @TODO Docs: at your crate's top level, use either self::prudent, or crate:;prudent (but NOT
@@ -103,7 +105,7 @@ pub use crate::linted_untested::PRUDENT_INTERNAL_LINTED_VERSION;
 /// }
 /// ```
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_fn;
+pub use crate::frontend_untested::internal_prudent_unsafe_fn;
 
 // Same `compile_fail` tests as listed above for `unsafe_fn`, but here we validate the error
 // numbers.
@@ -149,13 +151,13 @@ pub const _: () = {};
 //----------------------
 
 #[doc(hidden)]
-pub use crate::linted_untested::internal_prudent_unsafe_fn_internal_build_tuple_tree;
+pub use crate::frontend_untested::internal_prudent_unsafe_fn_internal_build_tuple_tree;
 
 #[doc(hidden)]
-pub use crate::linted_untested::internal_prudent_unsafe_fn_internal_build_accessors_and_call;
+pub use crate::frontend_untested::internal_prudent_unsafe_fn_internal_build_accessors_and_call;
 
 #[doc(hidden)]
-pub use crate::linted_untested::internal_prudent_unsafe_fn_internal_access_tuple_tree_field;
+pub use crate::frontend_untested::internal_prudent_unsafe_fn_internal_access_tuple_tree_field;
 //----------------------
 
 /// ```compile_fail
@@ -187,7 +189,7 @@ pub use crate::linted_untested::internal_prudent_unsafe_fn_internal_access_tuple
 #[doc = include_str!("../violations_coverage/unsafe_method/unused_expect_unsafe/some_args.rs")]
 /// ```
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_method;
+pub use crate::frontend_untested::internal_prudent_unsafe_method;
 
 /// ```compile_fail,E0133
 #[doc = include_str!("../violations_coverage/unsafe_method/sneaked_unsafe/arg.rs")]
@@ -209,10 +211,10 @@ pub const _: () = {};
 //----------------------
 
 #[doc(hidden)]
-pub use crate::linted_untested::internal_prudent_unsafe_method_internal_check_args_etc;
+pub use crate::frontend_untested::internal_prudent_unsafe_method_internal_check_args_etc;
 
 #[doc(hidden)]
-pub use crate::linted_untested::internal_prudent_unsafe_method_internal_build_accessors_check_args_call;
+pub use crate::frontend_untested::internal_prudent_unsafe_method_internal_build_accessors_check_args_call;
 //----------------------
 
 #[allow(clippy::useless_attribute)]
@@ -259,21 +261,21 @@ pub use crate::linted_untested::internal_prudent_unsafe_method_internal_build_ac
 /// }
 /// ```
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_static_set;
+pub use crate::frontend_untested::internal_prudent_unsafe_static_set;
 //----------------------
 
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_ref;
+pub use crate::frontend_untested::internal_prudent_unsafe_ref;
 //----------------------
 
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_mut;
+pub use crate::frontend_untested::internal_prudent_unsafe_mut;
 //----------------------
 
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_val;
+pub use crate::frontend_untested::internal_prudent_unsafe_val;
 //----------------------
 
 #[doc(inline)]
-pub use crate::linted_untested::internal_prudent_unsafe_set;
+pub use crate::frontend_untested::internal_prudent_unsafe_set;
 //----------------------

src/lib.rs

@@ -120,18 +120,18 @@ macro_rules! internal_coverage_positive {
     };
 }
 
-pub mod unlinted;
+pub mod backend;
 
 /// Linted macros.
-#[path = "linted_internal.rs"]
-mod linted_untested;
+#[path = "frontend_unlinted.rs"]
+mod frontend_untested;
 
-#[path = "linted_with_tests.rs"]
+#[path = "frontend_with_tests.rs"]
 #[doc(hidden)]
 pub mod linted;
 
 /// No need to be public. The only functionality is macros, which are exported even if private.
-mod linted_loader;
+mod frontend_loader;
 
 const _VERIFY_CRATE_NAME: () = {
     let path = core::module_path!().as_bytes();

src/linted.rs

@@ -5,7 +5,7 @@
 // https://github.com/prudent-rs/prudent/, https://crates.io/crates/prudent and
 // https://docs.rs/prudent/latest/prudent.
 
-// For docs see linted_with_tests.rs
+// For docs see frontend_with_tests.rs
 #![allow(missing_docs)]
 
 #[doc(hidden)]
@@ -19,7 +19,7 @@ const _VERIFY_MODULE_PATH: () = {
         [b'p', b'r', b'u', b'd', b'e', b'n', b't', b':', b':', ..]
     ) {
         panic!(
-            "Use ONLY linted.rs in your crate(s). Do not use linted_internal.rs, as that is internal."
+            "Use ONLY linted.rs in your crate(s). Do not use frontend_unlinted.rs, as that is internal."
         );
     }
 };
@@ -61,7 +61,7 @@ macro_rules! internal_prudent_unsafe_fn {
                 // block(s).
                 //
                 // The rest of this comment block/lines exists the same in both linted.rs and
-                // linted_internal.rs, but it applies to linted.rs ONLY.
+                // frontend_unlinted.rs, but it applies to linted.rs ONLY.
                 //
                 // (That minimizes the number of differences between those two files.)
                 //
@@ -115,7 +115,7 @@ macro_rules! internal_prudent_unsafe_fn {
                 // Ensure that $fn is not safe, but `unsafe`. Using
                 // https://doc.rust-lang.org/reference/types/function-item.html#r-type.fn-item.coercion
                 let _ = if false {
-                    ::prudent::unlinted::expecting_unsafe_fn::fun
+                    ::prudent::backend::expecting_unsafe_fn::fun
                 } else {
                     fun
                 };
@@ -274,7 +274,7 @@ macro_rules! internal_prudent_unsafe_method {
                             #[expect(unsafe_code)]
                         )?
                         let rref = &( $self );
-                        ::prudent::unlinted::shared_to_mut( rref )
+                        ::prudent::backend::shared_to_mut( rref )
                     };
                     #[allow(unused_mut)]
                     #[allow(invalid_value)] // for &str and other types where zeroed() issues invalid_value warning.
@@ -512,13 +512,13 @@ pub use internal_prudent_unsafe_mut;
 macro_rules! internal_prudent_unsafe_val {
     ($ptr:expr) => {{
         let ptr: *const _ = $ptr;
-        ::prudent::unlinted::expect_copy_ptr(ptr);
+        ::prudent::backend::expect_copy_ptr(ptr);
         unsafe { *ptr }
     }};
     ($ptr:expr, $ptr_type:ty) => {{
         let ptr = $ptr;
         let ptr = ptr as *const $ptr_type;
-        ::prudent::unlinted::expect_copy_ptr(ptr);
+        ::prudent::backend::expect_copy_ptr(ptr);
         unsafe { *ptr }
     }};
 }