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

use std::fmt::{Debug, Formatter, Result};
use std::sync::Mutex;

use sway_ir::Type;

use crate::decl_engine::DeclRefFunction;
use crate::language::parsed::MethodName;
use crate::semantic_analysis::TypeCheckContext;
use crate::{Engines, TypeBinding, TypeId, TypeInfo};

pub trait Observer {
    fn on_trace(&self, _msg: &str) {}

    fn on_before_method_resolution(
        &self,
        _ctx: &TypeCheckContext<'_>,
        _method_name: &TypeBinding<MethodName>,
        _args_types: &[TypeId],
    ) {
    }

    fn on_after_method_resolution(
        &self,
        _ctx: &TypeCheckContext<'_>,
        _method_name: &TypeBinding<MethodName>,
        _args_types: &[TypeId],
        _new_ref: DeclRefFunction,
        _new_type_id: TypeId,
    ) {
    }

    fn on_after_ir_type_resolution(
        &self,
        _engines: &Engines,
        _ctx: &sway_ir::Context,
        _type_info: &TypeInfo,
        _ir_type: &Type,
    ) {
    }
}

#[derive(Default)]
pub struct ObservabilityEngine {
    observer: Mutex<Option<Box<dyn Observer>>>,
    trace: Mutex<bool>,
}

unsafe impl Send for ObservabilityEngine {}
unsafe impl Sync for ObservabilityEngine {}

impl Debug for ObservabilityEngine {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.debug_struct("ObservabilityEngine")
            .field("trace", &self.trace)
            .finish()
    }
}

impl ObservabilityEngine {
    pub fn set_observer(&self, observer: Box<dyn Observer>) {
        let mut obs = self.observer.lock().unwrap();
        *obs = Some(observer);
    }

    pub fn raise_on_before_method_resolution(
        &self,
        ctx: &TypeCheckContext,
        method_name: &TypeBinding<MethodName>,
        arguments_types: &[TypeId],
    ) {
        if let Some(obs) = self.observer.lock().unwrap().as_mut() {
            obs.on_before_method_resolution(ctx, method_name, arguments_types);
        }
    }

    pub fn raise_on_after_method_resolution(
        &self,
        ctx: &TypeCheckContext,
        method_name: &TypeBinding<MethodName>,
        arguments_types: &[TypeId],
        ref_function: DeclRefFunction,
        tid: TypeId,
    ) {
        if let Some(obs) = self.observer.lock().unwrap().as_mut() {
            obs.on_after_method_resolution(ctx, method_name, arguments_types, ref_function, tid);
        }
    }

    pub fn raise_on_after_ir_type_resolution(
        &self,
        engines: &Engines,
        ctx: &sway_ir::Context,
        type_info: &TypeInfo,
        ir_type: &Type,
    ) {
        if let Some(obs) = self.observer.lock().unwrap().as_mut() {
            obs.on_after_ir_type_resolution(engines, ctx, type_info, ir_type);
        }
    }

    pub(crate) fn trace(&self, get_txt: impl FnOnce() -> String) {
        let trace = self.trace.lock().unwrap();
        if *trace {
            if let Some(obs) = self.observer.lock().unwrap().as_mut() {
                obs.on_trace(&get_txt());
            }
        }
    }

    pub fn enable_trace(&self, enable: bool) {
        let mut trace = self.trace.lock().unwrap();
        *trace = enable
    }
}