xir 0.1.4

Blah-blah intermediate representation
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

use crate::{block_argument::BlockArgument, context::Context, Operation};
use core::cell::RefCell;

/// A value.
#[derive(Clone, Copy, Debug)]
pub enum Value<'a> {
    /// A block argument.
    BlockArgument(BlockArgument<'a>),
    /// An operation value.
    OperationValue(OperationValue<'a>),
}

/// An operation value.
#[derive(Clone, Copy, Debug)]
pub struct OperationValue<'a> {
    inner: &'a RefCell<OperationValueInner<'a>>,
}

#[derive(Debug)]
struct OperationValueInner<'a> {
    operation: Operation<'a>,
    index: usize,
}

impl<'a> OperationValue<'a> {
    /// Creates an operation value.
    pub fn new(context: &'a Context<'a>, operation: Operation<'a>, index: usize) -> Self {
        Self {
            inner: context
                .allocator()
                .alloc(RefCell::new(OperationValueInner { operation, index })),
        }
    }

    /// Returns an operation.
    pub fn operation(&self) -> Operation<'a> {
        self.inner.borrow().operation
    }

    /// Returns an index.
    pub fn index(&self) -> usize {
        self.inner.borrow().index
    }

    /// Replaces a value.
    pub fn replace(&self, operation: Operation<'a>, index: usize) {
        *self.inner.borrow_mut() = OperationValueInner { operation, index }
    }
}

impl<'a> From<OperationValue<'a>> for Value<'a> {
    fn from(value: OperationValue<'a>) -> Self {
        Self::OperationValue(value)
    }
}