Struct DocumentAnalysis 

pub struct DocumentAnalysis {

    pub source: String,
    pub line_index: LineIndex,
    pub root: Option<SyntaxNode>,
    pub include_tree: Option<IncludeTree>,
    pub main_path: Option<PathBuf>,
    pub diagnostics: Vec<SemanticDiagnostic>,
    pub type_map: HashMap<(u32, u32), Type>,
    pub scope_store: ScopeStore,
    pub scope_extents: Vec<(ScopeId, (u32, u32))>,
    pub definition_map: HashMap<(String, RootSymbolKind), (PathBuf, u32, u32)>,
    pub doc_map: HashMap<(u32, u32), DocComment>,
    pub include_doc_maps: Option<HashMap<PathBuf, HashMap<(u32, u32), DocComment>>>,
    pub class_super: HashMap<String, String>,
    pub sig_definition_locations: Option<HashMap<String, (PathBuf, u32)>>,
}

Result of document-level analysis: source, AST, diagnostics, scope, types, definition map, doc maps, class hierarchy.

Fields

source: String

Main document source (what the client has).

line_index: LineIndex

Line index for the main document.

root: Option<SyntaxNode>

Program root (main file); None if parse failed.

include_tree: Option<IncludeTree>

When Some, the document has includes; tree holds main + included files.

main_path: Option<PathBuf>

Path of the main document (when file URI), for go-to-def on include.

diagnostics: Vec<SemanticDiagnostic>

Semantic and parse diagnostics.

type_map: HashMap<(u32, u32), Type>

Map from expression span (start, end) to inferred type.

scope_store: ScopeStore

scope_extents: Vec<(ScopeId, (u32, u32))>

Scope extent (ScopeId, (start_byte, end_byte)) for scope_at_offset.

definition_map: HashMap<(String, RootSymbolKind), (PathBuf, u32, u32)>

(name, kind) -> (path, start_byte, end_byte) for root-level symbols.

doc_map: HashMap<(u32, u32), DocComment>

Map from declaration (start_byte, end_byte) to parsed Doxygen-style documentation.

include_doc_maps: Option<HashMap<PathBuf, HashMap<(u32, u32), DocComment>>>

When Some (with include_tree), doc_map per included file path.

class_super: HashMap<String, String>

Class name -> superclass name (for visibility: subclass can see protected).

sig_definition_locations: Option<HashMap<String, (PathBuf, u32)>>

When Some, function/global name -> (path, 0-based line) from .sig files for hover/definition links.

Implementations

impl DocumentAnalysis

pub fn new_with_options(options: &DocumentAnalysisOptions<'_>) -> Self

Run parsing and analysis from options.

When main_path is set and build_include_tree succeeds, uses the include tree and analyzes with included files and signature_roots. Otherwise parses a single file (or uses existing_root when provided) and optionally uses signature_roots.

pub fn new( source: &str, main_path: Option<&Path>, signature_roots: &[SyntaxNode], existing_root: Option<SyntaxNode>, sig_definition_locations: Option<HashMap<String, (PathBuf, u32)>>, ) -> Self

Run parsing and analysis for the given source.

Convenience wrapper around Self::new_with_options. When main_path is Some and build_include_tree succeeds, uses the include tree; otherwise parses a single file (or uses existing_root when provided, e.g. from incremental reparse).

pub fn symbol_at_offset(&self, byte_offset: u32) -> Option<ResolvedSymbol>

Resolve the symbol at the given byte offset (e.g. variable, function, class, global). Returns None if there is no root, no token at offset, or the identifier does not resolve.

pub fn type_at_offset(&self, byte_offset: u32) -> Option<Type>

Type at the given byte offset. Looks up the node at offset in the type map, then walks ancestors until a type is found.

pub fn definition_span_for( &self, name: &str, kind: RootSymbolKind, ) -> Option<(PathBuf, u32, u32)>

Definition span for a root-level symbol: (path, start_byte, end_byte). Returns None if the name/kind is not in the definition map.

pub fn minimal(source: String) -> Self

Build minimal document state with only source and line index (no parse/analysis). Used by the LSP to update the document buffer immediately on did_change so that subsequent changes are applied to the correct base; analysis overwrites this when it completes.

pub fn minimal_with_root(source: String, root: SyntaxNode) -> Self

Like Self::minimal but keeps the given root so the next incremental reparse can reuse it. Use when reparse succeeded and analysis will run async; keeps the tree available for the next edit.

pub fn from_parse_only(source: &str) -> Self

Build document state from source using parse only (no semantic analysis). Use when full analysis panics so the LSP can still provide syntax highlighting and basic features.

Trait Implementations

impl Debug for DocumentAnalysis

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.