Struct StateWorkingSet

pub struct StateWorkingSet<'a> {
    pub permanent_state: &'a EngineState,
    pub delta: StateDelta,
    pub files: FileStack,
    pub search_predecls: bool,
    pub parse_errors: Vec<ParseError>,
    pub parse_warnings: Vec<ParseWarning>,
    pub compile_errors: Vec<CompileError>,
}

A temporary extension to the global state. This handles bridging between the global state and the additional declarations and scope changes that are not yet part of the global scope.

This working set is created by the parser as a way of handling declarations and scope changes that may later be merged or dropped (and not merged) depending on the needs of the code calling the parser.

Fields

permanent_state: &'a EngineState

delta: StateDelta

files: FileStack

search_predecls: bool

Whether or not predeclarations are searched when looking up a command (used with aliases)

parse_errors: Vec<ParseError>

parse_warnings: Vec<ParseWarning>

compile_errors: Vec<CompileError>

Implementations

impl<'a> StateWorkingSet<'a>

pub fn new(permanent_state: &'a EngineState) -> Self

pub fn permanent(&self) -> &EngineState

pub fn error(&mut self, parse_error: ParseError)

pub fn warning(&mut self, parse_warning: ParseWarning)

pub fn num_files(&self) -> usize

pub fn num_virtual_paths(&self) -> usize

pub fn num_decls(&self) -> usize

pub fn num_blocks(&self) -> usize

pub fn num_modules(&self) -> usize

pub fn unique_overlay_names(&self) -> HashSet<&[u8]>

pub fn num_overlays(&self) -> usize

pub fn add_decl(&mut self, decl: Box<dyn Command>) -> DeclId

pub fn use_decls(&mut self, decls: Vec<(Vec<u8>, DeclId)>)

pub fn use_modules(&mut self, modules: Vec<(Vec<u8>, ModuleId)>)

pub fn use_variables(&mut self, variables: Vec<(Vec<u8>, VarId)>)

pub fn add_predecl(&mut self, decl: Box<dyn Command>) -> Option<DeclId>

pub fn find_or_create_plugin( &mut self, identity: &PluginIdentity, make: impl FnOnce() -> Arc<dyn RegisteredPlugin>, ) -> Arc<dyn RegisteredPlugin>

pub fn update_plugin_registry(&mut self, item: PluginRegistryItem)

pub fn merge_predecl(&mut self, name: &[u8]) -> Option<DeclId>

pub fn move_predecls_to_overlay(&mut self)

pub fn hide_decl(&mut self, name: &[u8]) -> Option<DeclId>

pub fn hide_decls(&mut self, decls: &[Vec<u8>])

pub fn add_block(&mut self, block: Arc<Block>) -> BlockId

pub fn add_module( &mut self, name: &str, module: Module, comments: Vec<Span>, ) -> ModuleId

pub fn get_module_comments(&self, module_id: ModuleId) -> Option<&[Span]>

pub fn next_span_start(&self) -> usize

pub fn global_span_offset(&self) -> usize

pub fn files(&self) -> impl Iterator<Item = &CachedFile>

pub fn get_contents_of_file(&self, file_id: FileId) -> Option<&[u8]>

pub fn add_file(&mut self, filename: String, contents: &[u8]) -> FileId

pub fn add_virtual_path( &mut self, name: String, virtual_path: VirtualPath, ) -> VirtualPathId

pub fn get_span_for_filename(&self, filename: &str) -> Option<Span>

pub fn get_span_for_file(&self, file_id: FileId) -> Span

Panics: On invalid FileId

Use with care

pub fn get_span_contents(&self, span: Span) -> &[u8]

pub fn enter_scope(&mut self)

pub fn exit_scope(&mut self)

pub fn find_predecl(&self, name: &[u8]) -> Option<DeclId>

pub fn find_decl(&self, name: &[u8]) -> Option<DeclId>

pub fn find_module(&self, name: &[u8]) -> Option<ModuleId>

pub fn contains_decl_partial_match(&self, name: &[u8]) -> bool

pub fn next_var_id(&self) -> VarId

pub fn list_variables(&self) -> Vec<&[u8]>

pub fn find_variable(&self, name: &[u8]) -> Option<VarId>

pub fn find_variable_in_current_frame(&self, name: &[u8]) -> Option<VarId>

pub fn add_variable( &mut self, name: Vec<u8>, span: Span, ty: Type, mutable: bool, ) -> VarId

pub fn get_cwd(&self) -> String

👎Deprecated since 0.92.3: please use EngineState::cwd() instead

Returns the current working directory as a String, which is guaranteed to be canonicalized. Returns an empty string if $env.PWD doesn’t exist, is not a String, or is not an absolute path.

It does NOT consider modifications to the working directory made on a stack.

pub fn get_env_var(&self, name: &str) -> Option<&Value>

pub fn get_config(&self) -> &Arc<Config>

Returns a reference to the config stored at permanent state

At runtime, you most likely want to call Stack::get_config() because this method does not capture environment updates during runtime.

pub fn set_variable_type(&mut self, var_id: VarId, ty: Type)

pub fn set_variable_const_val(&mut self, var_id: VarId, val: Value)

pub fn get_variable(&self, var_id: VarId) -> &Variable

pub fn get_variable_if_possible(&self, var_id: VarId) -> Option<&Variable>

pub fn get_constant(&self, var_id: VarId) -> Result<&Value, ParseError>

pub fn get_decl(&self, decl_id: DeclId) -> &dyn Command

pub fn get_decl_mut(&mut self, decl_id: DeclId) -> &mut Box<dyn Command>

pub fn get_signature(&self, decl: &dyn Command) -> Signature

pub fn find_commands_by_predicate( &self, predicate: impl Fn(&[u8]) -> bool, ignore_deprecated: bool, ) -> Vec<(Vec<u8>, Option<String>, CommandType)>

pub fn get_block(&self, block_id: BlockId) -> &Arc<Block>

pub fn get_module(&self, module_id: ModuleId) -> &Module

pub fn get_block_mut(&mut self, block_id: BlockId) -> &mut Block

pub fn has_overlay(&self, name: &[u8]) -> bool

pub fn find_overlay(&self, name: &[u8]) -> Option<&OverlayFrame>

pub fn last_overlay_name(&self) -> &[u8]

pub fn last_overlay(&self) -> &OverlayFrame

pub fn last_overlay_mut(&mut self) -> &mut OverlayFrame

pub fn decls_of_overlay(&self, name: &[u8]) -> HashMap<Vec<u8>, DeclId>

Collect all decls that belong to an overlay

pub fn add_overlay( &mut self, name: Vec<u8>, origin: ModuleId, decls: Vec<(Vec<u8>, DeclId)>, modules: Vec<(Vec<u8>, ModuleId)>, prefixed: bool, )

pub fn remove_overlay(&mut self, name: &[u8], keep_custom: bool)

pub fn render(self) -> StateDelta

pub fn build_desc(&self, spans: &[Span]) -> (String, String)

pub fn find_block_by_span(&self, span: Span) -> Option<Arc<Block>>

pub fn find_module_by_span(&self, span: Span) -> Option<ModuleId>

pub fn find_virtual_path(&self, name: &str) -> Option<&VirtualPath>

pub fn get_virtual_path( &self, virtual_path_id: VirtualPathId, ) -> &(String, VirtualPath)

pub fn add_span(&mut self, span: Span) -> SpanId

Trait Implementations

impl<'a> GetSpan for &'a StateWorkingSet<'a>

fn get_span(&self, span_id: SpanId) -> Span

impl<'a> SourceCode for &StateWorkingSet<'a>

fn read_span<'b>( &'b self, span: &SourceSpan, context_lines_before: usize, context_lines_after: usize, ) -> Result<Box<dyn SpanContents<'_> + 'b>, MietteError>

Read the bytes for a specific span from this SourceCode, keeping a certain number of lines before and after the span as context.