Struct Compilation 

pub struct Compilation {

    pub hot_index: u32,
    pub records: Option<CompilationRecords>,
    pub options: Arc<CompilerOptions>,
    pub entries: Entry,
    pub global_entry: EntryData,
    pub dependency_factories: FxHashMap<DependencyType, Arc<dyn ModuleFactory>>,
    pub dependency_templates: FxHashMap<DependencyTemplateType, Arc<dyn DependencyTemplate>>,
    pub runtime_modules: IdentifierMap<Box<dyn RuntimeModule>>,
    pub runtime_modules_hash: IdentifierMap<RspackHashDigest>,
    pub runtime_modules_code_generation_source: IdentifierMap<BoxSource>,
    pub chunk_graph: ChunkGraph,
    pub chunk_by_ukey: ChunkByUkey,
    pub chunk_group_by_ukey: ChunkGroupByUkey,
    pub entrypoints: IndexMap<String, ChunkGroupUkey>,
    pub async_entrypoints: Vec<ChunkGroupUkey>,
    pub emitted_assets: DashSet<String, BuildHasherDefault<FxHasher>>,
    pub plugin_driver: Arc<PluginDriver>,
    pub buildtime_plugin_driver: Arc<PluginDriver>,
    pub resolver_factory: Arc<ResolverFactory>,
    pub loader_resolver_factory: Arc<ResolverFactory>,
    pub named_chunks: FxHashMap<String, ChunkUkey>,
    pub named_chunk_groups: FxHashMap<String, ChunkGroupUkey>,
    pub runtime_template: RuntimeTemplate,
    pub async_modules_artifact: AsyncModulesArtifact,
    pub dependencies_diagnostics_artifact: DependenciesDiagnosticsArtifact,
    pub side_effects_optimize_artifact: SideEffectsOptimizeArtifact,
    pub module_ids_artifact: ModuleIdsArtifact,
    pub chunk_ids_artifact: ChunkIdsArtifact,
    pub code_generation_results: BindingCell<CodeGenerationResults>,
    pub cgm_hash_artifact: CgmHashArtifact,
    pub cgm_runtime_requirements_artifact: CgmRuntimeRequirementsArtifact,
    pub cgc_runtime_requirements_artifact: CgcRuntimeRequirementsArtifact,
    pub chunk_hashes_artifact: ChunkHashesArtifact,
    pub chunk_render_artifact: ChunkRenderArtifact,
    pub module_graph_cache_artifact: ModuleGraphCacheArtifact,
    pub module_static_cache_artifact: ModuleStaticCacheArtifact,
    pub chunk_render_cache_artifact: ChunkRenderCacheArtifact,
    pub imported_by_defer_modules_artifact: ImportedByDeferModulesArtifact,
    pub code_generated_modules: IdentifierSet,
    pub build_time_executed_modules: IdentifierSet,
    pub old_cache: Arc<Cache>,
    pub code_splitting_cache: CodeSplittingCache,
    pub incremental: Incremental,
    pub hash: Option<RspackHashDigest>,
    pub file_dependencies: ArcPathIndexSet,
    pub context_dependencies: ArcPathIndexSet,
    pub missing_dependencies: ArcPathIndexSet,
    pub build_dependencies: ArcPathIndexSet,
    pub value_cache_versions: ValueCacheVersions,
    pub module_executor: Option<ModuleExecutor>,
    pub modified_files: ArcPathSet,
    pub removed_files: ArcPathSet,
    pub make_artifact: MakeArtifact,
    pub input_filesystem: Arc<dyn ReadableFileSystem>,
    pub intermediate_filesystem: Arc<dyn IntermediateFileSystem>,
    pub output_filesystem: Arc<dyn WritableFileSystem>,
    pub is_rebuild: bool,
    pub compiler_context: Arc<CompilerContext>,
    /* private fields */
}

Fields

hot_index: u32

records: Option<CompilationRecords>

options: Arc<CompilerOptions>

entries: Entry

global_entry: EntryData

dependency_factories: FxHashMap<DependencyType, Arc<dyn ModuleFactory>>

dependency_templates: FxHashMap<DependencyTemplateType, Arc<dyn DependencyTemplate>>

runtime_modules: IdentifierMap<Box<dyn RuntimeModule>>

runtime_modules_hash: IdentifierMap<RspackHashDigest>

runtime_modules_code_generation_source: IdentifierMap<BoxSource>

chunk_graph: ChunkGraph

chunk_by_ukey: ChunkByUkey

chunk_group_by_ukey: ChunkGroupByUkey

entrypoints: IndexMap<String, ChunkGroupUkey>

async_entrypoints: Vec<ChunkGroupUkey>

emitted_assets: DashSet<String, BuildHasherDefault<FxHasher>>

plugin_driver: Arc<PluginDriver>

buildtime_plugin_driver: Arc<PluginDriver>

resolver_factory: Arc<ResolverFactory>

loader_resolver_factory: Arc<ResolverFactory>

named_chunks: FxHashMap<String, ChunkUkey>

named_chunk_groups: FxHashMap<String, ChunkGroupUkey>

runtime_template: RuntimeTemplate

async_modules_artifact: AsyncModulesArtifact

dependencies_diagnostics_artifact: DependenciesDiagnosticsArtifact

side_effects_optimize_artifact: SideEffectsOptimizeArtifact

module_ids_artifact: ModuleIdsArtifact

chunk_ids_artifact: ChunkIdsArtifact

code_generation_results: BindingCell<CodeGenerationResults>

cgm_hash_artifact: CgmHashArtifact

cgm_runtime_requirements_artifact: CgmRuntimeRequirementsArtifact

cgc_runtime_requirements_artifact: CgcRuntimeRequirementsArtifact

chunk_hashes_artifact: ChunkHashesArtifact

chunk_render_artifact: ChunkRenderArtifact

module_graph_cache_artifact: ModuleGraphCacheArtifact

module_static_cache_artifact: ModuleStaticCacheArtifact

chunk_render_cache_artifact: ChunkRenderCacheArtifact

imported_by_defer_modules_artifact: ImportedByDeferModulesArtifact

code_generated_modules: IdentifierSet

build_time_executed_modules: IdentifierSet

old_cache: Arc<Cache>

code_splitting_cache: CodeSplittingCache

incremental: Incremental

hash: Option<RspackHashDigest>

file_dependencies: ArcPathIndexSet

context_dependencies: ArcPathIndexSet

missing_dependencies: ArcPathIndexSet

build_dependencies: ArcPathIndexSet

value_cache_versions: ValueCacheVersions

module_executor: Option<ModuleExecutor>

modified_files: ArcPathSet

removed_files: ArcPathSet

make_artifact: MakeArtifact

input_filesystem: Arc<dyn ReadableFileSystem>

intermediate_filesystem: Arc<dyn IntermediateFileSystem>

output_filesystem: Arc<dyn WritableFileSystem>

is_rebuild: bool

A flag indicating whether the current compilation is being rebuilt.

Rebuild will include previous compilation data, so persistent cache will not recovery anything

compiler_context: Arc<CompilerContext>

Implementations

impl Compilation

pub const OPTIMIZE_CHUNKS_STAGE_BASIC: i32 = -10i32

pub const OPTIMIZE_CHUNKS_STAGE_DEFAULT: i32 = 0i32

pub const OPTIMIZE_CHUNKS_STAGE_ADVANCED: i32 = 10i32

pub const PROCESS_ASSETS_STAGE_ADDITIONAL: i32 = -2_000i32

pub const PROCESS_ASSETS_STAGE_PRE_PROCESS: i32 = -1_000i32

pub const PROCESS_ASSETS_STAGE_DERIVED: i32 = -200i32

pub const PROCESS_ASSETS_STAGE_ADDITIONS: i32 = -100i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE: i32 = 100i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: i32 = 200i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY: i32 = 300i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: i32 = 400i32

pub const PROCESS_ASSETS_STAGE_DEV_TOOLING: i32 = 500i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: i32 = 700i32

pub const PROCESS_ASSETS_STAGE_SUMMARIZE: i32 = 1_000i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: i32 = 2_500i32

pub const PROCESS_ASSETS_STAGE_AFTER_OPTIMIZE_HASH: i32 = 2_600i32

pub const PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: i32 = 3_000i32

pub const PROCESS_ASSETS_STAGE_ANALYSE: i32 = 4_000i32

pub const PROCESS_ASSETS_STAGE_REPORT: i32 = 5_000i32

pub fn new( compiler_id: CompilerId, options: Arc<CompilerOptions>, plugin_driver: Arc<PluginDriver>, buildtime_plugin_driver: Arc<PluginDriver>, resolver_factory: Arc<ResolverFactory>, loader_resolver_factory: Arc<ResolverFactory>, records: Option<CompilationRecords>, old_cache: Arc<OldCache>, incremental: Incremental, module_executor: Option<ModuleExecutor>, modified_files: ArcPathSet, removed_files: ArcPathSet, input_filesystem: Arc<dyn ReadableFileSystem>, intermediate_filesystem: Arc<dyn IntermediateFileSystem>, output_filesystem: Arc<dyn WritableFileSystem>, is_rebuild: bool, compiler_context: Arc<CompilerContext>, ) -> Self

pub fn id(&self) -> CompilationId

pub fn compiler_id(&self) -> CompilerId

pub fn swap_make_artifact_with_compilation(&mut self, other: &mut Compilation)

pub fn swap_make_artifact(&mut self, make_artifact: &mut MakeArtifact)

pub fn get_module_graph(&self) -> ModuleGraph<'_>

pub fn module_by_identifier( &self, identifier: &ModuleIdentifier, ) -> Option<&BoxModule>

pub fn get_module_graph_mut(&mut self) -> ModuleGraph<'_>

pub fn file_dependencies( &self, ) -> (impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>)

pub fn context_dependencies( &self, ) -> (impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>)

pub fn missing_dependencies( &self, ) -> (impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>)

pub fn build_dependencies( &self, ) -> (impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>, impl Iterator<Item = &ArcPath>)

pub fn get_import_var( &self, module: ModuleIdentifier, target_module: Option<&BoxModule>, user_request: &str, phase: ImportPhase, runtime: Option<&RuntimeSpec>, ) -> String

pub async fn add_entry( &mut self, entry: BoxDependency, options: EntryOptions, ) -> Result<()>

pub async fn add_entry_batch( &mut self, args: Vec<(BoxDependency, EntryOptions)>, ) -> Result<()>

pub async fn add_include( &mut self, args: Vec<(BoxDependency, EntryOptions)>, ) -> Result<()>

pub fn update_asset( &mut self, filename: &str, updater: impl FnOnce(BoxSource, BindingCell<AssetInfo>) -> Result<(BoxSource, BindingCell<AssetInfo>)>, ) -> Result<()>

pub fn emit_asset(&mut self, filename: String, asset: CompilationAsset)

pub fn delete_asset(&mut self, filename: &str)

pub fn rename_asset(&mut self, filename: &str, new_name: String)

pub fn par_rename_assets(&mut self, renames: Vec<(String, String)>)

pub fn assets(&self) -> &CompilationAssets

pub fn assets_mut(&mut self) -> &mut CompilationAssets

pub fn entrypoints(&self) -> &IndexMap<String, ChunkGroupUkey>

pub fn push_diagnostic(&mut self, diagnostic: Diagnostic)

pub fn extend_diagnostics( &mut self, diagnostics: impl IntoIterator<Item = Diagnostic>, )

pub fn diagnostics(&self) -> &[Diagnostic]

pub fn diagnostics_mut(&mut self) -> &mut Vec<Diagnostic>

pub fn get_errors(&self) -> impl Iterator<Item = &Diagnostic>

pub fn get_errors_sorted(&self) -> impl Iterator<Item = &Diagnostic>

Get sorted errors based on the factors as follows in order:

• module identifier
• error offset Rspack assumes for each offset, there is only one error. However, when it comes to the case that there are multiple errors with the same offset, the order of these errors will not be guaranteed.

pub fn get_warnings(&self) -> impl Iterator<Item = &Diagnostic>

pub fn get_warnings_sorted(&self) -> impl Iterator<Item = &Diagnostic>

Get sorted warnings based on the factors as follows in order:

• module identifier
• error offset Rspack assumes for each offset, there is only one error. However, when it comes to the case that there are multiple errors with the same offset, the order of these errors will not be guaranteed.

pub fn get_logging(&self) -> &CompilationLogging

pub fn get_stats(&self) -> Stats<'_>

pub fn add_named_chunk( name: String, chunk_by_ukey: &mut ChunkByUkey, named_chunks: &mut HashMap<String, ChunkUkey>, ) -> (ChunkUkey, bool)

pub fn add_chunk(chunk_by_ukey: &mut ChunkByUkey) -> ChunkUkey

pub async fn make(&mut self) -> Result<()>

pub async fn rebuild_module<T>( &mut self, module_identifiers: IdentifierSet, f: impl Fn(Vec<&BoxModule>) -> T, ) -> Result<T>

pub fn entry_modules(&self) -> IdentifierSet

pub fn entrypoint_by_name(&self, name: &str) -> &Entrypoint

pub async fn finish(&mut self, plugin_driver: Arc<PluginDriver>) -> Result<()>

pub async fn seal(&mut self, plugin_driver: Arc<PluginDriver>) -> Result<()>

pub fn assign_runtime_ids(&mut self)

pub fn get_chunk_graph_entries( &self, ) -> impl Iterator<Item = ChunkUkey> + use<'_>

pub async fn process_modules_runtime_requirements( &mut self, modules: IdentifierSet, plugin_driver: Arc<PluginDriver>, ) -> Result<()>

pub async fn process_chunks_runtime_requirements( &mut self, chunks: UkeySet<ChunkUkey>, entries: UkeySet<ChunkUkey>, plugin_driver: Arc<PluginDriver>, ) -> Result<()>

pub async fn create_hash( &mut self, plugin_driver: Arc<PluginDriver>, ) -> Result<()>

pub async fn runtime_modules_code_generation(&mut self) -> Result<()>

pub async fn create_module_hashes( &mut self, modules: IdentifierSet, ) -> Result<()>

pub fn add_runtime_module( &mut self, chunk_ukey: &ChunkUkey, module: Box<dyn RuntimeModule>, ) -> Result<()>

pub fn get_hash(&self) -> Option<&str>

pub async fn get_path<'b, 'a: 'b>( &'a self, filename: &Filename, data: PathData<'b>, ) -> Result<String>

pub async fn get_path_with_info<'b, 'a: 'b>( &'a self, filename: &Filename, data: PathData<'b>, info: &mut AssetInfo, ) -> Result<String>

pub async fn get_asset_path( &self, filename: &Filename, data: PathData<'_>, ) -> Result<String>

pub async fn get_asset_path_with_info( &self, filename: &Filename, data: PathData<'_>, ) -> Result<(String, AssetInfo)>

pub fn get_logger(&self, name: impl Into<String>) -> CompilationLogger

pub fn set_dependency_factory( &mut self, dependency_type: DependencyType, module_factory: Arc<dyn ModuleFactory>, )

pub fn get_dependency_factory( &self, dependency: &BoxDependency, ) -> Arc<dyn ModuleFactory>

pub fn set_dependency_template( &mut self, template_type: DependencyTemplateType, template: Arc<dyn DependencyTemplate>, )

pub fn get_dependency_template( &self, dep: &dyn DependencyCodeGeneration, ) -> Option<Arc<dyn DependencyTemplate>>

Trait Implementations

impl Debug for Compilation

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

Formats the value using the given formatter.