rspack_core 0.100.1

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

mod alternatives;
mod module_graph;

use std::sync::Arc;

pub use module_graph::SCOPE;
use rspack_collections::IdentifierSet;
use rspack_error::Result;
use rustc_hash::FxHashSet;

use super::{
  super::{codec::CacheCodec, storage::Storage},
  Occasion,
};
use crate::{
  FactorizeInfo,
  compilation::build_module_graph::BuildModuleGraphArtifact,
  utils::{FileCounter, ResourceId},
};

/// Make Occasion is used to save MakeArtifact
#[derive(Debug)]
pub struct MakeOccasion {
  codec: Arc<CacheCodec>,
}

impl MakeOccasion {
  pub fn new(codec: Arc<CacheCodec>) -> Self {
    Self { codec }
  }
}

#[async_trait::async_trait]
impl Occasion for MakeOccasion {
  type Artifact = BuildModuleGraphArtifact;

  #[tracing::instrument(name = "Cache::Occasion::Make::reset", skip_all)]
  fn reset(&self, storage: &mut dyn Storage) {
    storage.reset(module_graph::SCOPE);
  }

  #[tracing::instrument(name = "Cache::Occasion::Make::save", skip_all)]
  fn save(&self, storage: &mut dyn Storage, artifact: &BuildModuleGraphArtifact) {
    let BuildModuleGraphArtifact {
      // write all of field here to avoid forget to update occasion when add new fields
      // for module graph
      module_graph,
      side_effects_state_artifact: _,
      module_to_lazy_make,
      affected_modules,
      affected_dependencies,
      issuer_update_modules,
      // skip
      entry_dependencies: _,
      file_dependencies: _,
      context_dependencies: _,
      missing_dependencies: _,
      build_dependencies: _,
      make_failed_dependencies: _,
      make_failed_module: _,
    } = artifact;

    let mut need_update_modules = issuer_update_modules.clone();
    need_update_modules.extend(affected_modules.active());

    // The updated dependencies should be synced to persistent cache.
    let mg = module_graph;
    for dep_id in affected_dependencies.active() {
      if let Some(m) = mg.get_parent_module(dep_id) {
        need_update_modules.insert(*m);
      }
    }

    module_graph::save_module_graph(
      module_graph,
      module_to_lazy_make,
      affected_modules.removed(),
      &need_update_modules,
      storage,
      &self.codec,
    );
  }

  #[tracing::instrument(name = "Cache::Occasion::Make::recovery", skip_all)]
  async fn recovery(&self, storage: &dyn Storage) -> Result<BuildModuleGraphArtifact> {
    let (mg, module_to_lazy_make, entry_dependencies) =
      module_graph::recovery_module_graph(storage, &self.codec).await?;

    // regenerate statistical data
    // recovery make_failed_module
    let mut make_failed_module = IdentifierSet::default();
    // recovery *_dep
    let mut file_dep = FileCounter::default();
    let mut context_dep = FileCounter::default();
    let mut missing_dep = FileCounter::default();
    let mut build_dep = FileCounter::default();
    for (mid, module) in mg.modules() {
      let build_info = module.build_info();
      let resource_id = ResourceId::from(*mid);
      file_dep.add_files(&resource_id, &build_info.file_dependencies);
      context_dep.add_files(&resource_id, &build_info.context_dependencies);
      missing_dep.add_files(&resource_id, &build_info.missing_dependencies);
      build_dep.add_files(&resource_id, &build_info.build_dependencies);
      if !module.diagnostics().is_empty() {
        make_failed_module.insert(*mid);
      }
    }

    // recovery make_failed_dependencies
    let mut make_failed_dependencies = FxHashSet::default();
    for (dep_id, dep) in mg.dependencies() {
      if let Some(info) = FactorizeInfo::get_from(dep) {
        if !info.is_success() {
          make_failed_dependencies.insert(*dep_id);
        }
        let resource = dep_id.into();
        file_dep.add_files(&resource, info.file_dependencies());
        context_dep.add_files(&resource, info.context_dependencies());
        missing_dep.add_files(&resource, info.missing_dependencies());
      }
    }

    Ok(BuildModuleGraphArtifact {
      // write all of field here to avoid forget to update occasion when add new fields
      // temporary data set to default
      affected_modules: Default::default(),
      affected_dependencies: Default::default(),
      issuer_update_modules: Default::default(),

      side_effects_state_artifact: Default::default(),
      module_graph: mg,
      module_to_lazy_make,

      make_failed_module,
      make_failed_dependencies,
      entry_dependencies,
      file_dependencies: file_dep,
      context_dependencies: context_dep,
      missing_dependencies: missing_dep,
      build_dependencies: build_dep,
    })
  }
}