Skip to main content

nu_protocol/engine/
state_delta.rs

1use crate::{
2    Module, Span, TypeAlias,
3    ast::Block,
4    engine::{
5        CachedFile, Command, EngineState, OverlayFrame, ScopeFrame, Variable, VirtualPath,
6        description::Doccomments,
7    },
8};
9use std::sync::Arc;
10
11#[cfg(feature = "plugin")]
12use crate::{PluginRegistryItem, RegisteredPlugin};
13
14/// A delta (or change set) between the current global state and a possible future global state. Deltas
15/// can be applied to the global state to update it to contain both previous state and the state held
16/// within the delta.
17#[derive(Clone)]
18pub struct StateDelta {
19    pub(super) files: Vec<CachedFile>,
20    pub(super) virtual_paths: Vec<(String, VirtualPath)>,
21    pub(super) vars: Vec<Variable>,          // indexed by VarId
22    pub(super) decls: Vec<Box<dyn Command>>, // indexed by DeclId
23    pub blocks: Vec<Arc<Block>>,             // indexed by BlockId
24    pub(super) modules: Vec<Arc<Module>>,    // indexed by ModuleId
25    pub(super) type_aliases: Vec<TypeAlias>, // indexed by TypeAliasId
26    pub spans: Vec<Span>,                    // indexed by SpanId
27    pub(super) doccomments: Doccomments,
28    pub scope: Vec<ScopeFrame>,
29    #[cfg(feature = "plugin")]
30    pub(super) plugins: Vec<Arc<dyn RegisteredPlugin>>,
31    #[cfg(feature = "plugin")]
32    pub(super) plugin_registry_items: Vec<PluginRegistryItem>,
33}
34
35impl StateDelta {
36    pub fn new(engine_state: &EngineState) -> Self {
37        let last_overlay = engine_state.last_overlay(&[]);
38        let scope_frame = ScopeFrame::with_empty_overlay(
39            engine_state.last_overlay_name(&[]).to_owned(),
40            last_overlay.origin,
41            last_overlay.prefixed,
42        );
43
44        StateDelta {
45            files: vec![],
46            virtual_paths: vec![],
47            vars: vec![],
48            decls: vec![],
49            blocks: vec![],
50            modules: vec![],
51            type_aliases: vec![],
52            spans: vec![],
53            scope: vec![scope_frame],
54            doccomments: Doccomments::new(),
55            #[cfg(feature = "plugin")]
56            plugins: vec![],
57            #[cfg(feature = "plugin")]
58            plugin_registry_items: vec![],
59        }
60    }
61
62    pub fn num_files(&self) -> usize {
63        self.files.len()
64    }
65
66    pub fn num_virtual_paths(&self) -> usize {
67        self.virtual_paths.len()
68    }
69
70    pub fn num_vars(&self) -> usize {
71        self.vars.len()
72    }
73
74    pub fn num_decls(&self) -> usize {
75        self.decls.len()
76    }
77
78    pub fn num_blocks(&self) -> usize {
79        self.blocks.len()
80    }
81
82    pub fn num_modules(&self) -> usize {
83        self.modules.len()
84    }
85
86    pub fn num_type_aliases(&self) -> usize {
87        self.type_aliases.len()
88    }
89
90    pub fn last_scope_frame_mut(&mut self) -> &mut ScopeFrame {
91        self.scope
92            .last_mut()
93            .expect("internal error: missing required scope frame")
94    }
95
96    pub fn last_scope_frame(&self) -> &ScopeFrame {
97        self.scope
98            .last()
99            .expect("internal error: missing required scope frame")
100    }
101
102    pub fn last_overlay_mut(&mut self) -> Option<&mut OverlayFrame> {
103        let last_scope = self
104            .scope
105            .last_mut()
106            .expect("internal error: missing required scope frame");
107
108        if let Some(last_overlay_id) = last_scope.active_overlays.last() {
109            Some(
110                &mut last_scope
111                    .overlays
112                    .get_mut(last_overlay_id.get())
113                    .expect("internal error: missing required overlay")
114                    .1,
115            )
116        } else {
117            None
118        }
119    }
120
121    pub fn last_overlay(&self) -> Option<&OverlayFrame> {
122        let last_scope = self
123            .scope
124            .last()
125            .expect("internal error: missing required scope frame");
126
127        if let Some(last_overlay_id) = last_scope.active_overlays.last() {
128            Some(
129                &last_scope
130                    .overlays
131                    .get(last_overlay_id.get())
132                    .expect("internal error: missing required overlay")
133                    .1,
134            )
135        } else {
136            None
137        }
138    }
139
140    pub fn enter_scope(&mut self) {
141        self.scope.push(ScopeFrame::new());
142    }
143
144    pub fn exit_scope(&mut self) {
145        self.scope.pop();
146    }
147
148    pub fn get_file_contents(&self) -> &[CachedFile] {
149        &self.files
150    }
151}