Struct CachedModule 

pub struct CachedModule {

    pub content_hash: u64,
    pub mtime_secs: u64,
    pub file_size: u64,
    pub last_access_secs: u64,
    pub exports: Vec<CachedExport>,
    pub imports: Vec<CachedImport>,
    pub re_exports: Vec<CachedReExport>,
    pub dynamic_imports: Vec<CachedDynamicImport>,
    pub require_calls: Vec<CachedRequireCall>,
    pub package_path_references: Vec<String>,
    pub member_accesses: Vec<MemberAccess>,
    pub whole_object_uses: Vec<String>,
    pub dynamic_import_patterns: Vec<CachedDynamicImportPattern>,
    pub has_cjs_exports: bool,
    pub has_angular_component_template_url: bool,
    pub unused_import_bindings: Vec<String>,
    pub type_referenced_import_bindings: Vec<String>,
    pub value_referenced_import_bindings: Vec<String>,
    pub suppressions: Vec<CachedSuppression>,
    pub unknown_suppression_kinds: Vec<CachedUnknownSuppressionKind>,
    pub line_offsets: Vec<u32>,
    pub complexity: Vec<FunctionComplexity>,
    pub flag_uses: Vec<FlagUse>,
    pub class_heritage: Vec<ClassHeritageInfo>,
    pub injection_tokens: Vec<(String, String)>,
    pub local_type_declarations: Vec<CachedLocalTypeDeclaration>,
    pub public_signature_type_references: Vec<CachedPublicSignatureTypeReference>,
    pub namespace_object_aliases: Vec<CachedNamespaceObjectAlias>,
    pub iconify_prefixes: Vec<String>,
    pub iconify_icon_names: Vec<String>,
    pub auto_import_candidates: Vec<String>,
    pub directives: Vec<String>,
    pub client_only_dynamic_import_spans: Vec<u32>,
    pub security_sinks: Vec<SinkSite>,
    pub security_sinks_skipped: u32,
    pub security_unresolved_callee_sites: Vec<SkippedSecurityCalleeSite>,
    pub tainted_bindings: Vec<TaintedBinding>,
    pub sanitized_sink_args: Vec<SanitizedSinkArg>,
    pub security_control_sites: Vec<SecurityControlSite>,
    pub callee_uses: Vec<CalleeUse>,
    pub misplaced_directives: Vec<MisplacedDirectiveSite>,
    pub inline_server_action_exports: Vec<String>,
    pub di_key_sites: Vec<DiKeySite>,
    pub has_dynamic_provide: bool,
    pub component_props: Vec<ComponentProp>,
    pub has_props_attrs_fallthrough: bool,
    pub has_define_expose: bool,
    pub has_define_model: bool,
    pub has_unharvestable_props: bool,
    pub component_emits: Vec<ComponentEmit>,
    pub angular_inputs: Vec<AngularInputMember>,
    pub angular_outputs: Vec<AngularOutputMember>,
    pub angular_component_selectors: Vec<AngularComponentSelector>,
    pub angular_used_selectors: Vec<String>,
    pub angular_entry_component_refs: Vec<String>,
    pub has_dynamic_component_render: bool,
    pub has_unharvestable_emits: bool,
    pub has_dynamic_emit: bool,
    pub has_emit_whole_object_use: bool,
    pub load_return_keys: Vec<LoadReturnKey>,
    pub has_unharvestable_load: bool,
    pub has_load_data_whole_use: bool,
    pub component_functions: Vec<ComponentFunction>,
    pub react_props: Vec<ComponentProp>,
    pub hook_uses: Vec<HookUse>,
    pub render_edges: Vec<RenderEdge>,
    pub svelte_dispatched_events: Vec<DispatchedEvent>,
    pub svelte_listened_events: Vec<String>,
    pub has_dynamic_dispatch: bool,
}

Cached data for a single module.

Fields

content_hash: u64

xxh3 hash of the file content.

mtime_secs: u64

File modification time (seconds since epoch) for fast cache validation. When mtime+size match the on-disk file, we skip reading file content entirely.

file_size: u64

File size in bytes for fast cache validation.

last_access_secs: u64

Seconds-since-epoch at the time this entry was last WRITTEN (first parse or content-change refresh). NOT updated on cache-hit reads: update_cache already iterates every in-scope file every run, so refreshing on read would collapse the LRU to “last run this file was discovered” for every retained entry. With write-only refresh, the LRU genuinely targets stale (in-scope-but-unchanged-for-many-runs) entries. Used by CacheStore::save for write-time eviction ordering.

exports: Vec<CachedExport>

Exported symbols.

imports: Vec<CachedImport>

Import specifiers.

re_exports: Vec<CachedReExport>

Re-export specifiers.

dynamic_imports: Vec<CachedDynamicImport>

Dynamic import specifiers.

require_calls: Vec<CachedRequireCall>

require() specifiers.

package_path_references: Vec<String>

Package names statically referenced through package path resolution.

member_accesses: Vec<MemberAccess>

Static member accesses (e.g., Status.Active).

whole_object_uses: Vec<String>

Identifiers used as whole objects (Object.values, for..in, spread, etc.).

dynamic_import_patterns: Vec<CachedDynamicImportPattern>

Dynamic import patterns with partial static resolution.

has_cjs_exports: bool

Whether this module uses CJS exports.

has_angular_component_template_url: bool

Whether this module declares at least one Angular @Component({ templateUrl: ... }) decorator. Mirrors ModuleInfo.has_angular_component_template_url so the CRAP-inherit walker’s gate survives a warm-cache load.

unused_import_bindings: Vec<String>

Local names of import bindings that are never referenced in this file.

type_referenced_import_bindings: Vec<String>

Local import bindings referenced from type positions.

value_referenced_import_bindings: Vec<String>

Local import bindings referenced from value positions.

suppressions: Vec<CachedSuppression>

Inline suppression directives.

unknown_suppression_kinds: Vec<CachedUnknownSuppressionKind>

Suppression tokens that did not parse to any known IssueKind. See #449.

line_offsets: Vec<u32>

Pre-computed line-start byte offsets for O(log N) byte-to-line/col conversion.

complexity: Vec<FunctionComplexity>

Per-function complexity metrics.

flag_uses: Vec<FlagUse>

Feature flag use sites.

class_heritage: Vec<ClassHeritageInfo>

Heritage metadata for exported classes.

injection_tokens: Vec<(String, String)>

Angular InjectionToken<Interface> (token, interface) pairs (#920).

local_type_declarations: Vec<CachedLocalTypeDeclaration>

Local type-capable declarations.

public_signature_type_references: Vec<CachedPublicSignatureTypeReference>

Type references from exported public signatures.

namespace_object_aliases: Vec<CachedNamespaceObjectAlias>

Namespace-import aliases re-exported through an object literal (export const API = { foo } where foo is import * as foo from './bar').

iconify_prefixes: Vec<String>

Iconify collection prefixes found in static icon props (issue #608).

iconify_icon_names: Vec<String>

Nuxt UI icon class suffixes found in static script-side icon properties (issue #955).

auto_import_candidates: Vec<String>

Bare identifier names that are candidates for convention auto-import resolution (issue #704). Content-local, so they round-trip through the cache; resolution against the plugin table happens at graph-build time.

directives: Vec<String>

File-level string directives ("use client", "use server"). Content-local, round-trips through the cache so the security client-server-leak detector sees directives on warm-cache loads.

client_only_dynamic_import_spans: Vec<u32>

Byte-offset starts of next/dynamic(..., { ssr: false }) dynamic imports. Content-local, round-trips so the security client-server-leak BFS sees the ssr:false client-only escape hatch on warm-cache loads.

security_sinks: Vec<SinkSite>

Captured security sink sites (category-blind). Round-trips through the cache so the catalogue-driven tainted_sink detector sees sinks on warm-cache loads.

security_sinks_skipped: u32

Count of sink-shaped nodes whose callee could not be flattened to a static path. Round-trips so the in-band blind-spot count is stable.

security_unresolved_callee_sites: Vec<SkippedSecurityCalleeSite>

Span-level diagnostics for skipped security sink callees.

tainted_bindings: Vec<TaintedBinding>

Local bindings tied to the member-access path they were sourced from. Round-trips so the security tainted_sink source-to-sink association sees source-tainted bindings on warm-cache loads.

sanitized_sink_args: Vec<SanitizedSinkArg>

Direct sink arguments recognized as sanitizer calls.

security_control_sites: Vec<SecurityControlSite>

Defensive control call sites for security surface output.

callee_uses: Vec<CalleeUse>

Deduped statically flattenable callee paths. Round-trips so the boundaries.calls.forbidden detector sees call sites on warm-cache loads.

misplaced_directives: Vec<MisplacedDirectiveSite>

Misplaced "use client" / "use server" directive sites. Round-trips so the misplaced-directive detector sees them on warm-cache loads.

inline_server_action_exports: Vec<String>

Export local names of inline "use server" body Server Actions. Round-trips so the unused-server-action reclassifier sees them on warm-cache loads.

di_key_sites: Vec<DiKeySite>

Vue provide/inject and Svelte setContext/getContext key sites. Round-trips so the unprovided-inject detector sees them on warm-cache loads.

has_dynamic_provide: bool

Whether the module had an unknowable-key provide. Round-trips so the unprovided-inject project-wide abstain holds on warm-cache loads.

component_props: Vec<ComponentProp>

Vue <script setup> defineProps declared props. Round-trips so the unused-component-prop detector sees them on warm-cache loads.

has_props_attrs_fallthrough: bool

Whether the template spreads $attrs/$props/props or the defineProps return is rest-destructured. Round-trips for the abstain.

has_define_expose: bool

Whether the SFC calls defineExpose(...). Round-trips for the abstain.

has_define_model: bool

Whether the SFC calls defineModel(...). Round-trips for the abstain.

has_unharvestable_props: bool

Whether defineProps had an unharvestable type-reference argument. Round-trips for the abstain.

component_emits: Vec<ComponentEmit>

Vue <script setup> defineEmits declared events. Round-trips so the unused-component-emit detector sees them on warm-cache loads.

angular_inputs: Vec<AngularInputMember>

Angular component/directive inputs (@Input() decorators and signal input() / model() initializers). Round-trips so the unused-component-input detector sees them on warm-cache loads.

angular_outputs: Vec<AngularOutputMember>

Angular component/directive outputs (@Output() decorators and signal output() / outputFromObservable() initializers). Round-trips so the unused-component-output detector sees them on warm-cache loads.

angular_component_selectors: Vec<AngularComponentSelector>

Angular @Component declarations with their selector value(s). Round-trips so the Angular unrendered-component arm sees them on warm-cache loads.

angular_used_selectors: Vec<String>

Custom element selector tags referenced in this file’s Angular templates. Round-trips for the Angular unrendered-component used-selector union.

angular_entry_component_refs: Vec<String>

Angular route / bootstrap component class references. Round-trips for the Angular unrendered-component entry-point abstain.

has_dynamic_component_render: bool

Whether this file dynamically renders a component (project-wide abstain signal for the Angular unrendered-component detector). Round-trips.

has_unharvestable_emits: bool

Whether defineEmits had an unharvestable argument. Round-trips for the abstain.

has_dynamic_emit: bool

Whether an emit(<nonLiteral>) call was seen. Round-trips for the abstain.

has_emit_whole_object_use: bool

Whether the emit binding was used as a whole value. Round-trips for the abstain.

load_return_keys: Vec<LoadReturnKey>

SvelteKit load() return-object keys. Round-trips so the unused-load-data-key detector sees them on warm-cache loads.

has_unharvestable_load: bool

Whether this file’s load() body could not be harvested safely. Round-trips for the abstain.

has_load_data_whole_use: bool

Whether this file passes the whole data object opaquely. Round-trips for the unused-load-data-key abstain.

component_functions: Vec<ComponentFunction>

React/JSX component definitions. Round-trips so the React-health phases see them on warm-cache loads.

react_props: Vec<ComponentProp>

React component props. Round-trips so the React unused-component-prop arm sees them on warm-cache loads.

hook_uses: Vec<HookUse>

React hook call sites. Round-trips for the complexity-fold phase.

render_edges: Vec<RenderEdge>

React render edges (child name captured; resolution deferred to graph build). Round-trips so the render graph survives a warm cache.

svelte_dispatched_events: Vec<DispatchedEvent>

Svelte custom events dispatched via dispatch('<name>'). Round-trips so the unused-svelte-event detector sees them on warm-cache loads.

svelte_listened_events: Vec<String>

Svelte template on:<name> listener names on component tags. Round-trips so the project-wide listened set is correct on warm-cache loads.

has_dynamic_dispatch: bool

Whether a dispatch(<nonLiteral>) call or whole-dispatch-value use was seen. Round-trips for the unused-svelte-event abstain.

Trait Implementations

impl Clone for CachedModule

fn clone(&self) -> CachedModule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CachedModule

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

Formats the value using the given formatter.

impl<'__de> Decode<'__de> for CachedModule

impl Encode for CachedModule