yaspar-ir 2.7.1

This crate provides a few representations of SMT scripts and other functionalities.
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
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

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use crate::allocator::StrAllocator;
use crate::ast::{HasArenaAlt, Str};

/// A unifying trait to pull content from a wrapper type
///
/// This trait is an interface to accommodate different libraries.
pub trait Contains {
    type T: ?Sized;
    fn inner(&self) -> &Self::T;
}

impl<T> Contains for &T {
    type T = T;

    #[inline]
    fn inner(&self) -> &Self::T {
        self
    }
}

/// implement this trait if there exists some meta-data for `Self`
pub trait MetaData {
    type T: ?Sized;
    /// the meta-data itself
    fn meta_data(&self) -> &Self::T;

    /// display the meta-data
    fn display_meta_data(&self) -> String;
}

/// a unifying trait to obtain the representation of a wrapped enum
pub trait Repr {
    type T;
    fn repr(&self) -> &Self::T;
}

/// a trait that represents an object that can be allocated as `Out` using some environment
pub trait Allocatable<Env> {
    type Out;

    fn allocate(&self, env: &mut Env) -> Self::Out;
}

impl Contains for str {
    type T = str;

    #[inline]
    fn inner(&self) -> &Self::T {
        self
    }
}

impl MetaData for &str {
    type T = &'static str;

    #[inline]
    fn meta_data(&self) -> &Self::T {
        &""
    }

    fn display_meta_data(&self) -> String {
        "".into()
    }
}

impl<Env: HasArenaAlt> Allocatable<Env> for &str {
    type Out = Str;

    #[inline]
    fn allocate(&self, env: &mut Env) -> Self::Out {
        env.arena_alt().allocate_symbol(self)
    }
}

impl Contains for String {
    type T = str;

    #[inline]
    fn inner(&self) -> &Self::T {
        self
    }
}

impl MetaData for String {
    type T = &'static str;

    #[inline]
    fn meta_data(&self) -> &Self::T {
        &""
    }

    fn display_meta_data(&self) -> String {
        "".into()
    }
}

impl<Env: HasArenaAlt> Allocatable<Env> for String {
    type Out = Str;

    #[inline]
    fn allocate(&self, env: &mut Env) -> Self::Out {
        env.arena_alt().allocate_symbol(self)
    }
}

impl<T> MetaData for &T
where
    T: MetaData,
{
    type T = T::T;

    fn meta_data(&self) -> &Self::T {
        (*self).meta_data()
    }

    fn display_meta_data(&self) -> String {
        (*self).display_meta_data()
    }
}

impl<Env, T> Allocatable<Env> for &T
where
    T: Allocatable<Env>,
{
    type Out = T::Out;

    fn allocate(&self, env: &mut Env) -> Self::Out {
        (*self).allocate(env)
    }
}

/// This is the trait that captures a string with meta-data so that we can feed in
/// different representations of strings to APIs.
///
/// It can be used to allocate a symbol in some environment (usually a [crate::ast::Arena]).
///
/// It has the following impls:
/// * &str
/// * String
/// * Str
/// * u::Str (this one incldues non-trivial location information from the inputs)
pub trait AllocatableString<Env>: Allocatable<Env, Out = Str> + MetaData {}

impl<Env, T> AllocatableString<Env> for T where T: Allocatable<Env, Out = Str> + MetaData {}