rspack_core 0.7.11

rspack core
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use super::{
  after_seal::after_seal_pass, assign_runtime_ids::assign_runtime_ids,
  build_chunk_graph::pass::build_chunk_graph_pass, build_module_graph::build_module_graph_pass,
  chunk_ids::chunk_ids_pass, code_generation::code_generation_pass,
  create_chunk_assets::create_chunk_assets_pass, create_hash::create_hash_pass,
  create_module_assets::create_module_assets_pass, create_module_hashes::create_module_hashes_pass,
  finish_make::finish_make_pass, finish_module_graph::finish_module_graph_pass,
  finish_modules::finish_modules_pass, make::make_hook_pass, module_ids::module_ids_pass,
  optimize_chunk_modules::optimize_chunk_modules_pass, optimize_chunks::optimize_chunks_pass,
  optimize_code_generation::optimize_code_generation_pass,
  optimize_dependencies::optimize_dependencies_pass, optimize_modules::optimize_modules_pass,
  optimize_tree::optimize_tree_pass, process_assets::process_assets_pass,
  runtime_requirements::runtime_requirements_pass, seal::seal_pass, *,
};
use crate::{Compilation, SharedPluginDriver, cache::Cache, logger::Logger};

impl Compilation {
  pub async fn run_passes(
    &mut self,
    plugin_driver: SharedPluginDriver,
    cache: &mut dyn Cache,
  ) -> Result<()> {
    let logger = self.get_logger("rspack.Compiler");

    let start = logger.time("make hook");
    make_hook_pass(self, plugin_driver.clone(), cache).await?;
    build_module_graph_pass(self).await?;
    logger.time_end(start);

    finish_make_pass(self, plugin_driver.clone()).await?;

    let start = logger.time("finish compilation");
    finish_module_graph_pass(self, cache).await?;
    finish_modules_pass(self).await?;
    logger.time_end(start);

    // This is the end of first pass of build module graph which will be recovered for next compilation
    // add a checkpoint here since we may modify module graph later in incremental compilation
    // and we can recover to this checkpoint in the future
    if self.incremental.passes_enabled(IncrementalPasses::MAKE) {
      self.build_module_graph_artifact.module_graph.checkpoint();
    }
    if !self.options.mode.is_development() {
      self.module_static_cache_artifact.freeze();
    }

    let start = logger.time("seal compilation");
    seal_pass(self, plugin_driver.clone()).await?;

    optimize_dependencies_pass(self, plugin_driver.clone()).await?;

    build_chunk_graph_pass(self).await?;
    optimize_modules_pass(self, plugin_driver.clone()).await?;
    optimize_chunks_pass(self, plugin_driver.clone()).await?;

    optimize_tree_pass(self, plugin_driver.clone()).await?;
    optimize_chunk_modules_pass(self, plugin_driver.clone()).await?;

    module_ids_pass(self, plugin_driver.clone()).await?;
    chunk_ids_pass(self, plugin_driver.clone()).await?;
    assign_runtime_ids(self);

    optimize_code_generation_pass(self, plugin_driver.clone()).await?;
    create_module_hashes_pass(self).await?;
    code_generation_pass(self, plugin_driver.clone()).await?;
    runtime_requirements_pass(self, plugin_driver.clone()).await?;
    create_hash_pass(self, plugin_driver.clone()).await?;
    create_module_assets_pass(self, plugin_driver.clone()).await?;
    create_chunk_assets_pass(self, plugin_driver.clone()).await?;
    process_assets_pass(self, plugin_driver.clone()).await?;
    after_seal_pass(self, plugin_driver).await?;
    logger.time_end(start);

    if !self.options.mode.is_development() {
      self.module_static_cache_artifact.unfreeze();
    }
    Ok(())
  }
}