Struct ResolvedModule 

pub struct ResolvedModule {

    pub file_id: FileId,
    pub path: PathBuf,
    pub exports: Arc<[ExportInfo]>,
    pub re_exports: Vec<ResolvedReExport>,
    pub resolved_imports: Vec<ResolvedImport>,
    pub resolved_dynamic_imports: Vec<ResolvedImport>,
    pub resolved_dynamic_patterns: Vec<(DynamicImportPattern, Vec<FileId>)>,
    pub member_accesses: Arc<[MemberAccess]>,
    pub semantic_facts: Arc<[SemanticFact]>,
    pub whole_object_uses: Arc<[String]>,
    pub has_cjs_exports: bool,
    pub has_angular_component_template_url: bool,
    pub unused_import_bindings: HashSet<String, FxBuildHasher>,
    pub type_referenced_import_bindings: Vec<String>,
    pub value_referenced_import_bindings: Vec<String>,
    pub namespace_object_aliases: Vec<NamespaceObjectAlias>,
    pub exported_factory_returns: Arc<[FactoryReturnExport]>,
    pub exported_factory_return_object_shapes: Arc<[FactoryReturnObjectShapeExport]>,
    pub type_member_types: Arc<[TypeMemberTypeEntry]>,
}

Fully resolved module with all imports mapped to targets.

The Arc<[T]> fields are refcounted views of the same allocations owned by the source fallow_types::extract::ModuleInfo, not copies; see the note on that struct.

Fields

file_id: FileId

Unique file identifier.

path: PathBuf

Absolute path to the module file.

exports: Arc<[ExportInfo]>

All export declarations in this module.

re_exports: Vec<ResolvedReExport>

All re-exports with resolved targets.

resolved_imports: Vec<ResolvedImport>

All static imports with resolved targets.

resolved_dynamic_imports: Vec<ResolvedImport>

All dynamic imports with resolved targets.

resolved_dynamic_patterns: Vec<(DynamicImportPattern, Vec<FileId>)>

Dynamic import patterns and their matched target files.

member_accesses: Arc<[MemberAccess]>

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

semantic_facts: Arc<[SemanticFact]>

Typed semantic facts produced by extraction for cross-layer analysis.

whole_object_uses: Arc<[String]>

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

has_cjs_exports: bool

Whether this module uses CommonJS 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; see that field for the contract this gate enforces.

unused_import_bindings: HashSet<String, FxBuildHasher>

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 runtime/value positions.

namespace_object_aliases: Vec<NamespaceObjectAlias>

Namespace-import aliases re-exported through an object literal. See fallow_types::extract::NamespaceObjectAlias for the shape.

exported_factory_returns: Arc<[FactoryReturnExport]>

Exported free-function factories that provably return one class instance. See fallow_types::extract::FactoryReturnExport and issue #1441 (Part A).

exported_factory_return_object_shapes: Arc<[FactoryReturnObjectShapeExport]>

Object-literal factory-return shapes (export function createUi() { return { orders: factory.ordersPage } }), threaded from ModuleInfo for the analyze-layer member-crediting join. See issue #1858.

type_member_types: Arc<[TypeMemberTypeEntry]>

Named-type property types declared by this module’s top-level interfaces and type-literal aliases. See fallow_types::extract::TypeMemberTypeEntry and issue #1785.

Implementations

impl ResolvedModule

pub fn all_resolved_imports(&self) -> impl Iterator<Item = &ResolvedImport>

Iterate over all concrete resolved imports in source order buckets.

Includes static import/require edges and literal dynamic import() edges. Dynamic import patterns are intentionally excluded because they resolve to sets of files rather than single import specifiers.

pub fn all_resolved_source_edges( &self, ) -> impl Iterator<Item = ResolvedSourceEdge<'_>>

Iterate over every literal source edge that has one resolved target.

Includes static imports, literal dynamic imports, and re-export sources. Dynamic import patterns are excluded because they resolve to sets of files rather than single import specifiers.

Trait Implementations

impl Debug for ResolvedModule

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

Formats the value using the given formatter.

impl Default for ResolvedModule

fn default() -> ResolvedModule

Returns the “default value” for a type.