hax-rust-engine 0.3.7

The engine of the hax toolchain.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use pretty::{BoxAllocator, DocAllocator};
use std::ops::Deref as _;

/// A convenience alias tying the document builder to the global
/// [`pretty::BoxAllocator`].
pub type DocBuilder<A> = pretty::DocBuilder<'static, BoxAllocator, A>;

/// Convert a value into a document by-value.
///
/// Implementations typically delegate to [`ToDocument`] after adjusting the
/// input ownership (e.g., cloning or borrowing). It allows helpers to accept
/// either borrowed or owned values transparently.
pub trait ToDocumentOwned<P, A> {
    /// Produce a document using the provided printer.
    fn to_document_owned(self, printer: &P) -> DocBuilder<A>;
}

impl<P, A, T: ToDocument<P, A>> ToDocumentOwned<P, A> for &T {
    fn to_document_owned(self, printer: &P) -> DocBuilder<A> {
        self.to_document(printer)
    }
}

impl<P, A> ToDocumentOwned<P, A> for DocBuilder<A> {
    fn to_document_owned(self, _printer: &P) -> DocBuilder<A> {
        self
    }
}
impl<P, A> ToDocumentOwned<P, A> for &str {
    fn to_document_owned(self, _printer: &P) -> DocBuilder<A> {
        DocAllocator::as_string(&BoxAllocator, self)
    }
}
impl<P, A> ToDocumentOwned<P, A> for String {
    fn to_document_owned(self, _printer: &P) -> DocBuilder<A> {
        DocAllocator::as_string(&BoxAllocator, self)
    }
}
impl<P, A> ToDocumentOwned<P, A> for Option<&str> {
    fn to_document_owned(self, printer: &P) -> DocBuilder<A> {
        self.map(|s| s.to_document_owned(printer))
            .unwrap_or_else(|| DocAllocator::nil(&BoxAllocator))
    }
}

/// Convert a value into a document using the supplied printer.
///
/// This is the primary trait invoked throughout the pretty-printing pipeline;
/// it mirrors [`pretty::Pretty::pretty`] while giving access to printer-specific
/// context.
pub trait ToDocument<P: ?Sized, A> {
    /// Produce a document using the provided printer reference.
    fn to_document(&self, printer: &P) -> DocBuilder<A>;
}

impl<A, P, T: ToDocument<P, A>> ToDocument<P, A> for Box<T> {
    fn to_document(&self, printer: &P) -> DocBuilder<A> {
        self.deref().to_document(printer)
    }
}
impl<A, P, T: ToDocument<P, A>> ToDocument<P, A> for Option<T> {
    fn to_document(&self, printer: &P) -> DocBuilder<A> {
        self.as_ref()
            .map(|value| value.to_document(printer))
            .unwrap_or_else(|| DocAllocator::nil(&BoxAllocator))
    }
}
impl<A, P> ToDocument<P, A> for String {
    fn to_document(&self, _printer: &P) -> DocBuilder<A> {
        DocAllocator::as_string(&BoxAllocator, self)
    }
}
impl<A: Clone, P> ToDocument<P, A> for DocBuilder<A> {
    #[inline(always)]
    fn to_document(&self, _printer: &P) -> DocBuilder<A> {
        self.clone()
    }
}
impl<A: Clone, P, T> ToDocument<P, A> for &T
where
    T: ToDocument<P, A>,
{
    #[inline(always)]
    fn to_document(&self, printer: &P) -> DocBuilder<A> {
        (*self).to_document(printer)
    }
}