sway-core 0.71.0

Sway core language.
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

use sway_features::ExperimentalFeatures;

use crate::{
    build_config::DbgGeneration,
    language::parsed::{Declaration, TreeType},
    BuildTarget,
};

pub struct Context {
    pub experimental: ExperimentalFeatures,

    /// Indicates whether the module being parsed has a `configurable` block.
    module_has_configurable_block: bool,

    /// Unique suffix used to generate unique names for destructured structs.
    destructured_struct_unique_suffix: usize,

    /// Unique suffix used to generate unique names for destructured tuples.
    destructured_tuple_unique_suffix: usize,

    /// Unique suffix used to generate unique names for variables
    /// that store values matched in match expressions.
    match_expression_matched_value_unique_suffix: usize,

    /// Unique suffix used to generate unique names for for loops.
    for_unique_suffix: usize,

    /// The build target.
    build_target: BuildTarget,

    /// Indicates whether the `__dbg` intrinsic generates code or not
    dbg_generation: DbgGeneration,

    /// The program type.
    program_type: Option<TreeType>,

    /// Keeps track of the implementing type as we convert the tree.
    pub(crate) implementing_type: Option<Declaration>,

    /// Used to name anonymous impl contracts
    pub package_name: String,
}

impl Context {
    /// Create a new context.
    pub fn new(
        build_target: BuildTarget,
        dbg_generation: DbgGeneration,
        experimental: ExperimentalFeatures,
        package_name: &str,
    ) -> Self {
        Self {
            build_target,
            dbg_generation,
            experimental,
            module_has_configurable_block: std::default::Default::default(),
            destructured_struct_unique_suffix: std::default::Default::default(),
            destructured_tuple_unique_suffix: std::default::Default::default(),
            match_expression_matched_value_unique_suffix: std::default::Default::default(),
            for_unique_suffix: std::default::Default::default(),
            program_type: std::default::Default::default(),
            implementing_type: None,
            package_name: package_name.to_string(),
        }
    }

    /// Updates the value of `module_has_configurable_block`.
    pub fn set_module_has_configurable_block(&mut self, val: bool) {
        self.module_has_configurable_block = val;
    }

    /// Returns whether the module being parsed has a `configurable` block.
    pub fn module_has_configurable_block(&self) -> bool {
        self.module_has_configurable_block
    }

    /// Returns a unique suffix used to generate a unique name for a destructured struct.
    pub fn next_destructured_struct_unique_suffix(&mut self) -> usize {
        self.destructured_struct_unique_suffix += 1;
        self.destructured_struct_unique_suffix
    }

    /// Returns a unique suffix used to generate a unique name for a destructured tuple
    pub fn next_destructured_tuple_unique_suffix(&mut self) -> usize {
        self.destructured_tuple_unique_suffix += 1;
        self.destructured_tuple_unique_suffix
    }

    /// Returns a unique suffix used to generate a unique name for a variable
    /// that stores the value matched in a match expression.
    pub fn next_match_expression_matched_value_unique_suffix(&mut self) -> usize {
        self.match_expression_matched_value_unique_suffix += 1;
        self.match_expression_matched_value_unique_suffix
    }

    /// Returns a unique suffix used to generate a unique name for a destructured struct.
    pub fn next_for_unique_suffix(&mut self) -> usize {
        self.for_unique_suffix += 1;
        self.for_unique_suffix
    }

    /// Returns the build target.
    pub fn build_target(&self) -> BuildTarget {
        self.build_target
    }

    pub fn is_dbg_generation_full(&self) -> bool {
        matches!(self.dbg_generation, DbgGeneration::Full)
    }

    /// Returns the program type.
    pub fn program_type(&self) -> Option<TreeType> {
        self.program_type
    }

    /// Updates the value of `program_type`.
    pub fn set_program_type(&mut self, program_type: TreeType) {
        self.program_type = Some(program_type);
    }
}