sway-ir 0.71.0

Sway 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
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

//! A value representing a function-local variable.

use crate::{
    context::Context,
    irtype::{Type, TypeContent},
    pretty::DebugWithContext,
    Constant,
};

/// A wrapper around an [ECS](https://github.com/orlp/slotmap) handle into the
/// [`Context`].
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, DebugWithContext)]
pub struct LocalVar(#[in_context(local_vars)] pub slotmap::DefaultKey);

#[doc(hidden)]
#[derive(Clone, DebugWithContext)]
pub struct LocalVarContent {
    pub ptr_ty: Type,
    pub initializer: Option<Constant>,
    pub mutable: bool,
}

impl LocalVar {
    /// Return a new local of a specific type with an optional [`Constant`] initializer.  If a
    /// local is marked as mutable then it is guaranteed to be on the stack rather than in
    /// read-only memory.
    pub fn new(
        context: &mut Context,
        ty: Type,
        initializer: Option<Constant>,
        mutable: bool,
    ) -> Self {
        let ptr_ty = Type::new_typed_pointer(context, ty);
        let content = LocalVarContent {
            ptr_ty,
            initializer,
            mutable,
        };
        LocalVar(context.local_vars.insert(content))
    }

    /// Return the type of this local variable, which is always a pointer.
    pub fn get_type(&self, context: &Context) -> Type {
        context.local_vars[self.0].ptr_ty
    }

    /// Return the inner (pointed to) type.
    pub fn get_inner_type(&self, context: &Context) -> Type {
        let TypeContent::TypedPointer(inner_ty) = self.get_type(context).get_content(context)
        else {
            unreachable!("Local var type is always a pointer.")
        };
        *inner_ty
    }

    /// Return the initializer for this local variable.
    pub fn get_initializer<'a>(&self, context: &'a Context) -> Option<&'a Constant> {
        context.local_vars[self.0].initializer.as_ref()
    }

    /// Return whether this local variable is mutable.
    pub fn is_mutable(&self, context: &Context) -> bool {
        context.local_vars[self.0].mutable
    }

    /// Change this local variable's mutability.
    pub fn set_mutable(&self, context: &mut Context, mutable: bool) {
        context.local_vars[self.0].mutable = mutable;
    }
}

/// A wrapper around an [ECS](https://github.com/orlp/slotmap) handle into the
/// [`Context`].
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, DebugWithContext)]
pub struct GlobalVar(#[in_context(global_vars)] pub slotmap::DefaultKey);

#[doc(hidden)]
#[derive(Clone, DebugWithContext)]
pub struct GlobalVarContent {
    pub ptr_ty: Type,
    pub initializer: Option<Constant>,
    pub mutable: bool,
}

impl GlobalVar {
    /// Return a new Global of a specific type with an optional [`Constant`] initializer.  If a
    /// Global is marked as mutable then it is guaranteed to be on the stack rather than in
    /// read-only memory.
    pub fn new(
        context: &mut Context,
        ty: Type,
        initializer: Option<Constant>,
        mutable: bool,
    ) -> Self {
        let ptr_ty = Type::new_typed_pointer(context, ty);
        let content = GlobalVarContent {
            ptr_ty,
            initializer,
            mutable,
        };
        GlobalVar(context.global_vars.insert(content))
    }

    /// Return the type of this Global variable, which is always a pointer.
    pub fn get_type(&self, context: &Context) -> Type {
        context.global_vars[self.0].ptr_ty
    }

    /// Return the inner (pointed to) type.
    pub fn get_inner_type(&self, context: &Context) -> Type {
        let TypeContent::TypedPointer(inner_ty) = self.get_type(context).get_content(context)
        else {
            unreachable!("Global var type is always a pointer.")
        };
        *inner_ty
    }

    /// Return the initializer for this Global variable.
    pub fn get_initializer<'a>(&self, context: &'a Context) -> Option<&'a Constant> {
        context.global_vars[self.0].initializer.as_ref()
    }

    /// Return whether this Global variable is mutable.
    pub fn is_mutable(&self, context: &Context) -> bool {
        context.global_vars[self.0].mutable
    }

    /// Change this Global variable's mutability.
    pub fn set_mutable(&self, context: &mut Context, mutable: bool) {
        context.global_vars[self.0].mutable = mutable;
    }
}