frontend_linted/frontend_unlinted and backend

Author: peter-lyons-kehl

README.md

@@ -51,7 +51,7 @@ The pains (that pend [rust-lang/rust#110613](https://github.com/rust-lang/rust/i
   macros are loaded in your crate's namespace, and hence they can't use `$crate` metavariable to
   refer to the rest of the macros and non-macro functionality).
 - In doctests
-  - load with `any:` like `::prudent::load!(any: "linted.rs");`
+  - load with `any:` like `::prudent::load!(any: "frontend_linted.rs");`
   - import with `use crate::prudent::*;` which you put outside of your `fn main()`
   - have `fn main()`
     - do **not** have the test logic at the top level, otherwise rustdoc/doctest mechanism
@@ -117,7 +117,7 @@ let _todo = ();
 ```
 
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_method;
 struct SNonCopy {}
 impl SNonCopy {
@@ -137,7 +137,7 @@ fn main() {
 
 ## unsafe_method > self: mutable reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_method;
 struct SNonCopy {}
 impl SNonCopy {
@@ -156,7 +156,7 @@ fn main() {
 
 ## unsafe_method > self: by value
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_method;
 fn main() {
     {
@@ -190,7 +190,7 @@ fn main() {
 # unsafe_ref
 ## unsafe_ref - one arg, basic reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 const B: bool = true;
 const PT: *const bool = &B as *const bool;
@@ -203,7 +203,7 @@ fn main() {
 
 ## unsafe_ref - one arg, slice
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 const BS: [bool; 2] = [true, false];
 const PT: *const [bool] = &BS as *const [bool];
@@ -216,7 +216,7 @@ fn main() {
 
 ## unsafe_ref - one arg, dyn reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 # use core::fmt::Display;
 const B: bool = true;
@@ -228,7 +228,7 @@ fn main() {}
 
 ## unsafe_ref - two args, lifetimed reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 const B: bool = true;
 const PT: *const bool = &B as *const bool;
@@ -241,7 +241,7 @@ fn main() {
 
 ## unsafe_ref - two args, lifetimed dyn reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 use core::fmt::Display;
 const B: bool = true;
@@ -253,7 +253,7 @@ fn main() {}
 
 ## unsafe_ref - two args, lifetimed slice
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 const BS: [bool; 2] = [true, false];
 const PT: *const [bool] = &BS as *const [bool];
@@ -266,7 +266,7 @@ fn main() {
 
 ## unsafe_ref - two args, typed basic reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 const B: bool = true;
 const PT: *const bool = &B as *const bool;
@@ -279,7 +279,7 @@ fn main() {
 
 ## unsafe_ref - two args, typed slice
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 const BS: [bool; 2] = [true, false];
 const PT: *const [bool] = &BS as *const [bool];
@@ -292,7 +292,7 @@ fn main() {
 
 ## unsafe_ref - two args, typed dyn reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_ref;
 # use core::fmt::Display;
 const B: bool = true;
@@ -308,7 +308,7 @@ fn main() {
 # unsafe_mut
 ## unsafe_mut - one arg, basic reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 fn main() {
     let mut b: bool = true;
@@ -321,7 +321,7 @@ fn main() {
 
 ## unsafe_mut - one arg, slice
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 fn main() {
     let mut bs: [bool; 2] = [true, false];
@@ -334,7 +334,7 @@ fn main() {
 
 ## unsafe_mut - one arg, dyn reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 # use core::fmt::Display;
 fn main() {
@@ -348,7 +348,7 @@ fn main() {
 
 ## unsafe_mut - two args, lifetimed reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 fn main() {
     let b: &'static mut bool = Box::leak( Box::new(true) );
@@ -362,7 +362,7 @@ fn main() {
 
 ## unsafe_mut - two args, lifetimed dyn reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 # use core::fmt::Display;
 fn main() {
@@ -377,7 +377,7 @@ fn main() {
 
 ## unsafe_mut - two args, lifetimed slice
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 fn main() {
     let bs: &'static mut [bool] = Box::leak( Box::new([true, false]) );
@@ -391,7 +391,7 @@ fn main() {
 
 ## unsafe_mut - two args, typed basic reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 fn main() {
     let mut b: bool = true;
@@ -404,7 +404,7 @@ fn main() {
 
 ## unsafe_mut - two args, typed slice
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 fn main() {
     let bs: &'static mut [bool] = Box::leak( Box::new([true, false]) );
@@ -418,7 +418,7 @@ fn main() {
 
 ## unsafe_mut - two args, typed dyn reference
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_mut;
 # use core::fmt::Display;
 fn main() {
@@ -439,7 +439,7 @@ Only for types that implement/derive [core::marker::Copy].
 
 ## unsafe_val - one arg, basic
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_val;
 fn main() {
     const B: bool = true;
@@ -452,7 +452,7 @@ fn main() {
 
 ## unsafe_val - two args, typed
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_val;
 fn main() {
     const B: bool = true;
@@ -465,7 +465,7 @@ fn main() {
 
 # unsafe_set
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_set;
 fn main() {
     let mut b: bool = true;
@@ -477,7 +477,7 @@ fn main() {
 ```
 
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_set;
 struct SNonCopy {}
 fn main() {
@@ -493,7 +493,7 @@ fn main() {
 
 # unsafe_static_set
 ```rust
-::prudent::load!(any: "linted.rs");
+::prudent::load!(any: "frontend_linted.rs");
 use crate::prudent::unsafe_static_set;
 static mut B: bool = true;
 

src/linted.rs src/frontend_linted.rssrc/linted.rs renamed to src/frontend_linted.rs

@@ -1,4 +1,4 @@
-// A copy of prudent's linted.rs. Under Apache 2.0, MIT and BSD license.
+// A copy of prudent's frontend_linted.rs. Under Apache 2.0, MIT and BSD license.
 //
 // For the version of this file see PRUDENT_INTERNAL_LINTED_VERSION below. This may, or may not, be
 // compatible with newer versions of prudent. For the most recent version available see
@@ -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 frontend_unlinted.rs, as that is internal."
+            "Use ONLY frontend_linted.rs in your crate(s). Do not use frontend_unlinted.rs, as that is internal."
         );
     }
 };
@@ -60,13 +60,13 @@ macro_rules! internal_prudent_unsafe_fn {
                 // include any unsafe code/calls/casts on their  own without their own `unsafe{...}`
                 // block(s).
                 //
-                // The rest of this comment block/lines exists the same in both linted.rs and
-                // frontend_unlinted.rs, but it applies to linted.rs ONLY.
+                // The rest of this comment block/lines exists the same in both frontend_linted.rs
+                // and frontend_unlinted.rs, but it applies to frontend_linted.rs ONLY.
                 //
                 // (That minimizes the number of differences between those two files.)
                 //
-                // If this file is linted.rs (which then is passed to ::prudent::load!(...)), then
-                // here we can *not* refer to
+                // If this file is frontend_linted.rs (which then is passed to
+                // ::prudent::load!(...)), then here we can *not* refer to
                 // - $crate::unsafe_method, nor
                 // - crate::unsafe_method
                 //
@@ -81,7 +81,7 @@ macro_rules! internal_prudent_unsafe_fn {
                 // `unsafe_method`). So we add prefix `internal_prudent_`, and we refer to
                 // `internal_prudent_unsafe_method` instead.
                 //
-                // This applies to all other linted-to-linted macros calls in linted.rs.
+                // This applies to all other linted-to-linted macros calls in frontend_linted.rs.
                 let (tuple_tree, fun) = (internal_prudent_unsafe_fn_internal_build_tuple_tree!{ $($arg),+ }, $fn);
 
                 if false {

src/frontend_loader.rs

@@ -1,29 +1,29 @@
-// - 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")
+// - "Frontend"_ macros can (and do) invoke "backend" macros, but not the other way. That's because
+//   backend macros don't know the crate name where frontend macros were loaded.
+// - frontend 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 `backend`) from `prudent` crate under module `prudent`.
+    // re-export all (both `frontend` and `backend`) from `prudent` crate under module `prudent`.
     () => {
         $crate::load!( prudent );
     };
     // No lints.
     //
-    // re-export all (both `linted` and `backend`) from `prudent` crate, under given module name.
+    // re-export all (both `frontend` and `backend`) from `prudent` crate, under given module name.
     ( $module_name:ident ) => {
         /// prudent exported in a module
         mod $module_name {
-            $crate::reexport_macros!( ::prudent::linted );
-            $crate::reexport_non_macros!( ::prudent::linted );
+            $crate::reexport_macros!( ::prudent::frontend);
+            $crate::reexport_non_macros!( ::prudent::frontend );
         }
     };// -----------
 
-    // load `linted` from the given file; re-export `backend` from `prudent` crate; blend them
+    // load `frontend` 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.
@@ -106,7 +106,7 @@ macro_rules! load {
         // Without #[macro_use] we can't refer to internal macro names without importing them, even
         // if the macros exist in the user's namespace, that is, loaded with
         // ```
-        // ::prudent::load!(any: "path/to/linted.rs");
+        // ::prudent::load!(any: "path/to/frontend_linted.rs");
         // ```
         // or similar.
         #[macro_use]
@@ -115,7 +115,7 @@ macro_rules! load {
 
         #[cfg(not(any( $( $cfg_filter )* )))]
         #[allow(unused)]
-        pub use ::prudent::linted as internal_prudent_linted_loaded_or_aliased;
+        pub use ::prudent::frontend as internal_prudent_linted_loaded_or_aliased;
 
         mod $module_name {
             $crate::reexport_macros!(super::internal_prudent_linted_loaded_or_aliased);
@@ -127,7 +127,7 @@ macro_rules! load {
     }
 }
 
-/// Re-export macros from the given `linted`_module/path.
+/// Re-export macros from the given "frontend"_module/path.
 ///
 /// NOT a part of public API - internal.
 #[doc(hidden)]
@@ -157,7 +157,7 @@ macro_rules! reexport_macros {
 }
 
 /// Re-export
-/// 1. non-macros from the given `linted`_module/path. And
+/// 1. non-macros from the given "frontend"_module/path. And
 /// 2. anything needed from `backend`.
 ///
 /// NOT a part of public API - internal.

src/frontend_unlinted.rs

@@ -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 frontend_unlinted.rs, as that is internal."
+            "Use ONLY frontend_linted.rs in your crate(s). Do not use frontend_unlinted.rs, as that is internal."
         );
     }
 };
@@ -58,12 +58,12 @@ macro_rules! internal_prudent_unsafe_fn {
                 // include any unsafe code/calls/casts on their  own without their own `unsafe{...}`
                 // block(s).
                 //
-                // The rest of this comment block/lines exists the same in both linted.rs and
-                // frontend_unlinted.rs, but it applies to linted.rs ONLY.
+                // The rest of this comment block/lines exists the same in both frontend_linted.rs and
+                // frontend_unlinted.rs, but it applies to frontend_linted.rs ONLY.
                 //
                 // (That minimizes the number of differences between those two files.)
                 //
-                // If this file is linted.rs (which then is passed to ::prudent::load!(...)), then
+                // If this file is frontend_linted.rs (which then is passed to ::prudent::load!(...)), then
                 // here we can *not* refer to
                 // - $crate::unsafe_method, nor
                 // - crate::unsafe_method
@@ -79,7 +79,7 @@ macro_rules! internal_prudent_unsafe_fn {
                 // `unsafe_method`). So we add prefix `internal_prudent_`, and we refer to
                 // `internal_prudent_unsafe_method` instead.
                 //
-                // This applies to all other linted-to-linted macros calls in linted.rs.
+                // This applies to all other linted-to-linted macros calls in frontend_linted.rs.
                 let (tuple_tree, fun) = (::prudent::internal_prudent_unsafe_fn_internal_build_tuple_tree!{ $($arg),+ }, $fn);
 
                 if false {