Static references, multiple crates, and data from compile time to runtime - rust

Question

I have some multi-crate Rust library project. This includes one module for proc-macro definitions.
For sake of simplicity, let's supose that the project contains 3 diferent crates, crate_a, crate_b, crate_c.
crate_a it's mainly used to expose the public API's, organizing reexports...
crate_b is where the proc-macro lives.
crate_c contains a static reference of contents.
crate_a depends on both others crates. crate_b depends on crate_c.
The purpose of crate_c it's to hold data that one macro of the crate_b generates at compile time, and them wire them into a client main() function.
Code on lib.rs of crate_c:
use std::sync::Mutex;
use lazy_static::lazy_static;
lazy_static! {
pub static ref REGISTER_ENTITIES: Mutex<Vec<RegisterEntity<'static>>> = Mutex::new(Vec::new());
pub static ref QUERIES_TO_EXECUTE: Mutex<Vec<String>> = Mutex::new(Vec::new());
}
A example of the macro on crate_b:
#[proc_macro_attribute]
pub fn macro(_meta: CompilerTokenStream, input: CompilerTokenStream) -> CompilerTokenStream {
// Parses the function that this attribute is attached to
let func_res = syn::parse::<FunctionParser>(input);
if func_res.is_err() {
return quote! { fn main() {} }.into()
}
let func = func_res.ok().unwrap();
let sign = func.clone().sig;
let body = func.clone().block.stmts;
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
Handler::run().await; // Execute code that stores data on the `REGISTER_ENTITIES` static ref
});
// Saves data on the `QUERIES_TO_EXECUTE` static ref
let mut queries_tokens: Vec<TokenStream> = Vec::new();
wire_queries_to_execute(&mut queries_tokens);
// The final code wired in main()
quote! {
#[tokio::main]
async #sign {
{
#(#queries_tokens)*
}
#(#body)*
}
}.into()
}
where wire_queries_to_execute reduced for the example:
pub fn wire_queries_to_execute(manager_tokens: &mut Vec<TokenStream>) {
let mut queries = String::new();
for query in (*QUERIES_TO_EXECUTE).lock().unwrap().iter() {
queries.push_str(&(query.to_owned() + "->"));
}
let tokens = quote! {
*QUERIES_TO_EXECUTE.lock().unwrap() = #queries
.split("->")
.map(str::to_string)
.collect::<Vec<String>>();
DatabaseSyncOperations::from_query_register().await;
};
manager_tokens.push(tokens)
}
and then just the code used by some consumer of the library:
// use statements...
fn main() {
{
// here run, for example, queries to the database wired by the macro
}
// User's code
}
I can write some data to the static ref at compile time (when the macro runs) and then be retrieved. Is this always true?
Edit: For clarification, let's put an example:
At compile time macro saves some data into the static ref. Then, when the code of the user runs, it's able to fetch that data of the static ref. I wanted to know if there's some possibility of overwrite the data stored in the static ref by another program (or service, or whatever element) in the time between the compilation and the start the program.
Suppose that you, as user of my library, compile your binary, wait to hours, and then executes your binary.
What happens to that data? Change the value of two hours for the amount of time that you want, for the example.
How I can ensure that this data will be there, waiting for the runtime execution of the binary? Is possible that another program, thread or service of the OS, decides to allocate some data where resides the data of the static ref? Or it will be there until a reboot or a shutdown?
Even more, what it's the real connection between the data stored at runtime, and the one retrieved at runtime?
Or just, because it's a static ref it's stored inside the binary, and no such case as present above can happens?