1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

//! This crate allows data to write itself into Rust code (bake itself in).
//!
//! Types that implement the `Bake` trait can be written into Rust expressions,
//! which allows using Rust code itself as a zero-overhead "serialization" strategy.
//!
//! # Example
//! ```
//! use databake::*;
//! # extern crate alloc;
//! use alloc::borrow::Cow;
//!
//! let data = [Some((18, Cow::Borrowed("hi")))];
//! assert_eq!(
//!     data.bake(&Default::default()).to_string(),
//!     r#"[Some ((18i32 , alloc :: borrow :: Cow :: Borrowed ("hi")))]"#,
//! );
//! ```
//!
//! # Derive
//!
//! `Bake` can be automatically derived if the `derive` Cargo feature is enabled.
//!
//! ```
//! use databake::*;
//!
//! #[derive(Bake)]
//! #[databake(path = my_crate)]
//! struct MyStruct {
//!     number: u32,
//!     string: &'static str,
//!     slice: &'static [bool],
//! }
//!
//! #[derive(Bake)]
//! #[databake(path = my_crate)]
//! struct AnotherOne(MyStruct, char);
//! ```
//!
//! # Testing
//! The [`test_bake`] macro can be used to assert that a particular expression is a `Bake` fixed point.
//!
//! ```
//! # use databake::*;
//! # #[derive(Bake)]
//! # #[databake(path = my_crate)]
//! # struct MyStruct {
//! #   number: u32,
//! #   string: &'static str,
//! #   slice: &'static [bool],
//! # }
//! # #[derive(Bake)]
//! # #[databake(path = my_crate)]
//! # struct AnotherOne(MyStruct, char);
//! # fn main() {
//! test_bake!(
//!     AnotherOne,
//!     const, crate::AnotherOne(
//!         crate::MyStruct {
//!           number: 17u32,
//!           string: "foo",
//!           slice: &[true, false],
//!         },
//!         'b',
//!     ),
//!     my_crate,
//! );
//! # }
//! ```

mod alloc;
pub mod converter;
mod primitives;

#[doc(no_inline)]
pub use proc_macro2::TokenStream;

#[doc(no_inline)]
pub use quote::quote;

#[cfg(feature = "derive")]
pub use databake_derive::Bake;

use std::collections::HashSet;
use std::sync::Mutex;

/// A collection of crates that are required for the evaluation of some expression.
#[derive(Default)]
pub struct CrateEnv(Mutex<HashSet<&'static str>>);

impl CrateEnv {
    /// Adds a crate to this collection. This can be called concurrently
    /// and without `mut`.
    pub fn insert(&self, krate: &'static str) {
        self.0.lock().expect("poison").insert(krate);
    }
}

impl IntoIterator for CrateEnv {
    type Item = &'static str;
    type IntoIter = <HashSet<&'static str> as IntoIterator>::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_inner().expect("poison").into_iter()
    }
}

/// The `Bake` trait allows a piece of data to write itself into a Rust expression.
///
/// This can be used to generate files with hardcoded data.
pub trait Bake {
    /// Returns a [`TokenStream`] that would evaluate to `self`.
    ///
    /// Crates that are required for the evaluation of the [`TokenStream`] will be
    /// added to `ctx`.
    fn bake(&self, ctx: &CrateEnv) -> TokenStream;
}

/// Allows returning the size of data borrowed by a baked struct.
pub trait BakeSize: Sized + Bake {
    /// Returns the size
    fn borrows_size(&self) -> usize;
}

/// This macro tests that an expression evaluates to a value that bakes to the same expression.
///
/// Its mandatory arguments are a type and an expression (of that type).
///
/// ```
/// # use databake::test_bake;
/// test_bake!(usize, 18usize);
/// ```
///
/// ## `Const`
///
/// We usually want baked output to be const constructible. To test this, add the `const:` prefix to
/// the expression:
///
/// ```
/// # use databake::test_bake;
/// test_bake!(usize, const, 18usize);
/// ```
///
/// ## Crates and imports
///
/// As most output will need to reference its crate, and its not possible to name a crate from
/// within it, a third parameter can be used to specify the crate name. The `crate` identifier
/// in the original expression will be replaced by this in the expected output.
///
/// ```no_run
/// # use databake::*;
/// # struct MyStruct(usize);
/// # impl Bake for MyStruct {
/// #   fn bake(&self, _: &CrateEnv) -> TokenStream { unimplemented!() }
/// # }
/// # // We need an explicit main to put the struct at the crate root
/// # fn main() {
/// test_bake!(
///     MyStruct,
///     crate::MyStruct(42usize), // matches `::my_crate::MyStruct(42usize)`
///     my_crate,
/// );
/// # }
/// ```
///
/// A fourth, optional, parameter is a list of crate names that are expected to be added to the
/// `CrateEnv`. The `crate`-replacement crate will always be checked.
#[macro_export]
macro_rules! test_bake {
    ($type:ty, const, $expr:expr $(, $krate:ident)? $(, [$($env_crate:ident),+])? $(,)?) => {
        const _: &$type = &$expr;
        $crate::test_bake!($type, $expr $(, $krate)? $(, [$($env_crate),+])?);
    };

    ($type:ty, $expr:expr $(, $krate:ident)? $(, [$($env_crate:ident),+])? $(,)?) => {
        let env = Default::default();
        let expr: &$type = &$expr;
        let bake = $crate::Bake::bake(expr, &env).to_string();
        // For some reason `TokenStream` behaves differently in this line
        let expected_bake = $crate::quote!($expr).to_string().replace("::<", ":: <").replace(">::", "> ::");
        // Trailing commas are a mess as well
        let bake = bake.replace(" ,)", ")").replace(" ,]", "]").replace(" , }", " }").replace(" , >", " >");
        let expected_bake = expected_bake.replace(" ,)", ")").replace(" ,]", "]").replace(" , }", " }").replace(" , >", " >");
        $(
            let expected_bake = expected_bake.replace("crate", stringify!($krate));
        )?
        assert_eq!(bake, expected_bake);

        #[allow(unused_variables)]
        let _env = env.into_iter().collect::<std::collections::HashSet<_>>();
        $(
            assert!(_env.contains(stringify!($krate)), "Crate {:?} was not added to the CrateEnv", stringify!($krate));
        )?
        $(
            $(
                assert!(_env.contains(stringify!($env_crate)), "Crate {:?} was not added to the CrateEnv", stringify!($env_crate));
            )+
        )?
    };
}