chore: checkpoint before Python removal

vendor/const-random-macro/src/lib.rs

@@ -0,0 +1,57 @@
+#[allow(unused_extern_crates)]
+extern crate proc_macro;
+
+use proc_macro::*;
+use std::iter::once;
+mod span;
+use crate::span::{gen_random_bytes, gen_random};
+
+
+/// Create a TokenStream of an identifier out of a string
+fn ident(ident: &str) -> TokenStream {
+    TokenTree::from(Ident::new(ident, Span::call_site())).into()
+}
+
+#[proc_macro]
+pub fn const_random(input: TokenStream) -> TokenStream {
+    match &input.to_string()[..] {
+        "u8" => TokenTree::from(Literal::u8_suffixed(gen_random())).into(),
+        "u16" => TokenTree::from(Literal::u16_suffixed(gen_random())).into(),
+        "u32" => TokenTree::from(Literal::u32_suffixed(gen_random())).into(),
+        "u64" => TokenTree::from(Literal::u64_suffixed(gen_random())).into(),
+        "u128" => TokenTree::from(Literal::u128_suffixed(gen_random())).into(),
+        "i8" => TokenTree::from(Literal::i8_suffixed(gen_random())).into(),
+        "i16" => TokenTree::from(Literal::i16_suffixed(gen_random())).into(),
+        "i32" => TokenTree::from(Literal::i32_suffixed(gen_random())).into(),
+        "i64" => TokenTree::from(Literal::i64_suffixed(gen_random())).into(),
+        "i128" => TokenTree::from(Literal::i128_suffixed(gen_random())).into(),
+        "usize" => {
+            let value: TokenStream = TokenTree::from(Literal::u128_suffixed(gen_random())).into();
+            let type_cast: TokenStream = [value, ident("as"), ident("usize")]
+                .iter()
+                .cloned()
+                .collect();
+            TokenTree::from(Group::new(Delimiter::Parenthesis, type_cast)).into()
+        }
+        "isize" => {
+            let value: TokenStream = TokenTree::from(Literal::i128_suffixed(gen_random())).into();
+            let type_cast: TokenStream = [value, ident("as"), ident("isize")]
+                .iter()
+                .cloned()
+                .collect();
+            TokenTree::from(Group::new(Delimiter::Parenthesis, type_cast)).into()
+        }
+        byte_array if byte_array.starts_with("[u8 ; ") && byte_array.ends_with(']')=> {
+            let len = byte_array[6..byte_array.len()-1].parse().unwrap();
+            let mut random_bytes = vec![0; len];
+            gen_random_bytes(&mut random_bytes);
+            let array_parts: TokenStream = random_bytes.into_iter().flat_map(|byte|  {
+                let val = TokenTree::from(Literal::u8_suffixed(byte));
+                let comma = TokenTree::from(Punct::new(',', Spacing::Alone));
+                once(val).chain(once(comma))
+            }).collect();
+            TokenTree::from(Group::new(Delimiter::Bracket, array_parts)).into()
+        }
+        _ => panic!("Invalid type"),
+    }
+}

vendor/const-random-macro/src/span.rs

@@ -0,0 +1,104 @@
+use proc_macro::Span;
+use std::option_env;
+
+use once_cell::race::OnceBox;
+use tiny_keccak::{Xof, Hasher, Shake};
+
+
+static SEED: OnceBox<Vec<u8>> = OnceBox::new();
+
+fn get_seed() -> &'static [u8] {
+    &SEED.get_or_init(|| {
+        if let Some(value) = option_env!("CONST_RANDOM_SEED") {
+ 	    Box::new(value.as_bytes().to_vec())
+    	} else {
+            let mut value = [0u8; 32];
+            getrandom::getrandom(&mut value).unwrap();
+            Box::new(value.to_vec())
+        }
+    })[..]
+}
+
+pub(crate) fn gen_random<T: Random>() -> T {
+    Random::random()
+}
+
+pub(crate) fn gen_random_bytes(output: &mut [u8]) {
+    hash_stuff().squeeze(output)
+}
+
+pub(crate) trait Random {
+    fn random() -> Self;
+}
+
+fn hash_stuff() -> impl Xof {
+    let span = Span::call_site();
+    let mut hasher = Shake::v256();
+    hasher.update(get_seed());
+    hasher.update(&format!("{:?}", span).as_bytes());
+    hasher
+}
+
+impl Random for u64 {
+    fn random() -> Self {
+        let mut output = [0; 8];
+        hash_stuff().squeeze(&mut output);
+        Self::from_ne_bytes(output)
+    }
+}
+
+impl Random for u128 {
+    fn random() -> Self {
+        let mut output = [0; 16];
+        hash_stuff().squeeze(&mut output);
+        Self::from_ne_bytes(output)
+    }
+}
+
+impl Random for u8 {
+    fn random() -> Self {
+        u64::random() as u8
+    }
+}
+
+impl Random for u16 {
+    fn random() -> Self {
+        u64::random() as u16
+    }
+}
+
+impl Random for u32 {
+    fn random() -> Self {
+        u64::random() as u32
+    }
+}
+
+impl Random for i8 {
+    fn random() -> Self {
+        i64::random() as i8
+    }
+}
+
+impl Random for i16 {
+    fn random() -> Self {
+        i64::random() as i16
+    }
+}
+
+impl Random for i32 {
+    fn random() -> Self {
+        i64::random() as i32
+    }
+}
+
+impl Random for i64 {
+    fn random() -> Self {
+        u64::random() as i64
+    }
+}
+
+impl Random for i128 {
+    fn random() -> Self {
+        u128::random() as i128
+    }
+}