Struct Resolver 

pub struct Resolver {
    pub symbol_table: SymbolTable,
    pub anchors: HashMap<String, MonValue>,
    /* private fields */
}

Traverses a MonDocument to resolve imports, aliases, and spreads, and to validate data against schemas.

The Resolver is responsible for the semantic analysis of a parsed MON document from the [Parser]. It is a crucial step that transforms a syntactically correct document into a fully validated and usable data structure.

It performs several key tasks:

• Import Resolution: It parses and resolves import statements, loading symbols from other files and handling mon: URIs for built-in schemas. It also detects circular dependencies.
• Symbol Collection: It gathers all type definitions (like structs and enums) and anchors into a global AstSymbolTable.
• Alias & Spread Resolution: It replaces aliases (e.g., *my_anchor) and spreads (e.g., ...*my_anchor) with their corresponding values, effectively performing composition.
• Validation: It validates data against declared types using the :: operator (e.g., my_field :: MyType = ...), ensuring type safety and data integrity. This includes checking for missing/extra fields in structs and validating collection types.

Example: How to use the Resolver

While the main public entry point is the analyze function, you can use the Resolver directly if you need more control over the process, such as inspecting the symbol table or using a custom built-in schema path.

use mon_core::parser::Parser;
use mon_core::resolver::Resolver;
use mon_core::error::MonError;
use std::path::PathBuf;

let source = r###"
{
    MyStruct: #struct { name(String) },
    &my_data: { name: "Hello" },

    // This instance will be validated against MyStruct.
    instance :: MyStruct = *my_data
}
"###;
let file_path = PathBuf::from("my_file.mon");

// 1. The resolver needs a parsed document to work with.
let mut parser = Parser::new_with_name(source, file_path.to_string_lossy().to_string())?;
let document = parser.parse_document()?;

// 2. Create a new resolver.
let mut resolver = Resolver::new();

// 3. Resolve the document. This returns the final, validated document.
let resolved_document = resolver.resolve(document.clone(), source, file_path, None)?;

// You can now access the resolved data, symbol table, and anchors.
assert!(resolver.symbol_table.types.contains_key("MyStruct"));
assert!(resolver.anchors.contains_key("my_data"));

Fields

symbol_table: SymbolTable

anchors: HashMap<String, MonValue>

Implementations

impl Resolver

pub fn new() -> Self

Creates a new Resolver with a default search path for built-in schemas.

The default path is determined by Resolver::default_builtin_path.

pub fn with_builtin_path(path: PathBuf) -> Self

Creates a new Resolver with a custom search path for built-in schemas.

This is useful for testing or for applications that bundle their own schemas.

pub fn resolve( &mut self, document: MonDocument, source_text: &str, file_path: PathBuf, causing_import: Option<ImportStatement>, ) -> Result<MonDocument, ResolverError>

Recursively resolves a MonDocument.

This is the main entry point for the resolver’s logic. It takes a parsed document and performs the full semantic analysis lifecycle.

Arguments

• document: The parsed MonDocument to resolve.
• source_text: The original source code string, used for error reporting.
• file_path: The absolute path to the file being resolved, used for resolving relative imports.
• causing_import: An optional ImportStatement that triggered the resolution of this file, used for circular dependency tracking.

Errors

This function can return a ResolverError if any of the following occurs:

• A module specified in an import statement cannot be found (ResolverError::ModuleNotFound).
• A circular dependency is detected between imported modules (ResolverError::CircularDependency).
• An anchor, alias, or spread is used incorrectly.
• A validation error occurs when checking data against a schema (ResolverError::Validation).
• A parsing error occurs in an imported file.

Trait Implementations

impl Default for Resolver

fn default() -> Self

Returns the “default value” for a type.