incremental-query 0.2.0

implementation of an incremental compilation algorithm similar to rustc's
Documentation 
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

use std::fmt::Display;

use super::{
    context::Context,
    generation::Generation,
    query_parameter::{QueryParameter, TypeErasedQueryParam},
};

pub trait Query<'cx, T>: 'static + Copy + Clone {
    type Input: QueryParameter + 'cx;
    type Output: QueryParameter + 'cx;
    const NAME: &'static str;

    fn get_run_fn() -> ErasedQueryRun<T>;

    fn mode(&self) -> QueryMode {
        QueryMode::Cache
    }

    fn run(cx: &Context<'cx, T>, i: &Self::Input) -> Self::Output;
}

#[derive(PartialEq, Eq, Debug, Clone, Copy)]
pub enum QueryColor {
    Red,
    Green,
    Unknown,
}

pub type ErasedQueryRun<T = ()> = for<'cx> fn(
    &Context<'cx, T>,
    TypeErasedQueryParam<'cx>,
    &dyn Fn(u128) -> bool,
) -> (Option<TypeErasedQueryParam<'cx>>, u128);

pub struct QueryInstance<'cx, T> {
    pub run: ErasedQueryRun<T>,

    pub name: &'static str,

    pub mode: QueryMode,
    pub generation: Generation,

    // input so we can rerun it
    pub input: TypeErasedQueryParam<'cx>,

    // maybe we know what its output will be
    pub output: Option<TypeErasedQueryParam<'cx>>,

    pub output_hash: u128,

    pub color: QueryColor,
    pub transitively_has_always_dep: bool,
}

impl<T> Display for QueryInstance<'_, T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}#{:.4}", self.name, self.output_hash.to_string())
    }
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum QueryMode {
    /// Always rerun this query
    Always,
    /// always run this query once this generation
    /// if the generation number changes, gotta rerun!
    Generation,
    /// cache whenever possible
    Cache,
}