From d9551c5d77a7fd3b5d7f621e79f9c52831d6e08f Mon Sep 17 00:00:00 2001 From: Gengkun Date: Mon, 21 Oct 2024 17:02:10 +0800 Subject: [PATCH] refactor: incremental options name (#8175) --- crates/node_binding/binding.d.ts | 8 +- .../rspack_binding_options/src/options/mod.rs | 16 +-- .../src/options/raw_experiments.rs | 8 +- .../rspack_core/src/compiler/compilation.rs | 26 ++-- crates/rspack_core/src/compiler/hmr.rs | 12 +- .../src/unaffected_cache/incremental.rs | 8 +- .../src/case/new-incremental.ts | 11 +- .../src/processor/hot-new-incremental.ts | 11 +- .../tests/__snapshots__/Defaults.test.js.snap | 8 +- packages/rspack/etc/core.api.md | 120 +++++++++--------- packages/rspack/src/config/adapter.ts | 8 +- packages/rspack/src/config/defaults.ts | 8 +- packages/rspack/src/config/normalization.ts | 13 +- packages/rspack/src/config/zod.ts | 8 +- 14 files changed, 130 insertions(+), 135 deletions(-) diff --git a/crates/node_binding/binding.d.ts b/crates/node_binding/binding.d.ts index b1f466b1505..c389affbe29 100644 --- a/crates/node_binding/binding.d.ts +++ b/crates/node_binding/binding.d.ts @@ -1412,10 +1412,10 @@ export interface RawIncremental { emitAssets: boolean inferAsyncModules: boolean providedExports: boolean - collectModulesDiagnostics: boolean - moduleHashes: boolean - moduleCodegen: boolean - moduleRuntimeRequirements: boolean + dependenciesDiagnostics: boolean + modulesHashes: boolean + modulesCodegen: boolean + modulesRuntimeRequirements: boolean } export interface RawInfo { diff --git a/crates/rspack_binding_options/src/options/mod.rs b/crates/rspack_binding_options/src/options/mod.rs index e59380cfee1..f854fef01c9 100644 --- a/crates/rspack_binding_options/src/options/mod.rs +++ b/crates/rspack_binding_options/src/options/mod.rs @@ -86,17 +86,17 @@ impl TryFrom for CompilerOptions { if value.provided_exports { passes.insert(IncrementalPasses::PROVIDED_EXPORTS); } - if value.collect_modules_diagnostics { - passes.insert(IncrementalPasses::COLLECT_MODULES_DIAGNOSTICS); + if value.dependencies_diagnostics { + passes.insert(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS); } - if value.module_hashes { - passes.insert(IncrementalPasses::MODULE_HASHES); + if value.modules_hashes { + passes.insert(IncrementalPasses::MODULES_HASHES); } - if value.module_codegen { - passes.insert(IncrementalPasses::MODULE_CODEGEN); + if value.modules_codegen { + passes.insert(IncrementalPasses::MODULES_CODEGEN); } - if value.module_runtime_requirements { - passes.insert(IncrementalPasses::MODULE_RUNTIME_REQUIREMENTS); + if value.modules_runtime_requirements { + passes.insert(IncrementalPasses::MODULES_RUNTIME_REQUIREMENTS); } passes } diff --git a/crates/rspack_binding_options/src/options/raw_experiments.rs b/crates/rspack_binding_options/src/options/raw_experiments.rs index be68a6e834e..dd3ea3bd9f4 100644 --- a/crates/rspack_binding_options/src/options/raw_experiments.rs +++ b/crates/rspack_binding_options/src/options/raw_experiments.rs @@ -17,10 +17,10 @@ pub struct RawIncremental { pub emit_assets: bool, pub infer_async_modules: bool, pub provided_exports: bool, - pub collect_modules_diagnostics: bool, - pub module_hashes: bool, - pub module_codegen: bool, - pub module_runtime_requirements: bool, + pub dependencies_diagnostics: bool, + pub modules_hashes: bool, + pub modules_codegen: bool, + pub modules_runtime_requirements: bool, } #[allow(clippy::empty_structs_with_brackets)] diff --git a/crates/rspack_core/src/compiler/compilation.rs b/crates/rspack_core/src/compiler/compilation.rs index 89a9870a338..2166d7f3fb1 100644 --- a/crates/rspack_core/src/compiler/compilation.rs +++ b/crates/rspack_core/src/compiler/compilation.rs @@ -168,7 +168,7 @@ pub struct Compilation { pub named_chunk_groups: HashMap, pub async_modules: IdentifierSet, - pub modules_diagnostics: IdentifierMap>, + pub dependencies_diagnostics: IdentifierMap>, pub code_generation_results: CodeGenerationResults, pub cgm_hash_results: CgmHashResults, pub cgm_runtime_requirements_results: CgmRuntimeRequirementsResults, @@ -267,7 +267,7 @@ impl Compilation { named_chunk_groups: Default::default(), async_modules: Default::default(), - modules_diagnostics: Default::default(), + dependencies_diagnostics: Default::default(), code_generation_results: Default::default(), cgm_hash_results: Default::default(), cgm_runtime_requirements_results: Default::default(), @@ -1087,7 +1087,7 @@ impl Compilation { .can_read_mutations(IncrementalPasses::PROVIDED_EXPORTS) || self .incremental - .can_read_mutations(IncrementalPasses::COLLECT_MODULES_DIAGNOSTICS) + .can_read_mutations(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS) { self .unaffected_modules_cache @@ -1128,14 +1128,14 @@ impl Compilation { fn collect_dependencies_diagnostics(&mut self) { let mutations = self .incremental - .mutations_read(IncrementalPasses::COLLECT_MODULES_DIAGNOSTICS); + .mutations_read(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS); let modules = if let Some(mutations) = mutations { let revoked_modules = mutations.iter().filter_map(|mutation| match mutation { Mutation::ModuleRevoke { module } => Some(*module), _ => None, }); for revoked_module in revoked_modules { - self.modules_diagnostics.remove(&revoked_module); + self.dependencies_diagnostics.remove(&revoked_module); } self .unaffected_modules_cache @@ -1148,7 +1148,7 @@ impl Compilation { module_graph.modules().keys().copied().collect() }; let module_graph = self.get_module_graph(); - let modules_diagnostics: IdentifierMap> = modules + let dependencies_diagnostics: IdentifierMap> = modules .par_iter() .map(|module_identifier| { let mgm = module_graph @@ -1165,10 +1165,12 @@ impl Compilation { }) .collect(); let all_modules_diagnostics = if mutations.is_some() { - self.modules_diagnostics.extend(modules_diagnostics); - self.modules_diagnostics.clone() + self + .dependencies_diagnostics + .extend(dependencies_diagnostics); + self.dependencies_diagnostics.clone() } else { - modules_diagnostics + dependencies_diagnostics }; self.extend_diagnostics(all_modules_diagnostics.into_values().flatten()); } @@ -1247,13 +1249,13 @@ impl Compilation { let module_hashes_enabled = self .incremental - .can_read_mutations(IncrementalPasses::MODULE_HASHES); + .can_read_mutations(IncrementalPasses::MODULES_HASHES); let module_codegen_enabled = self .incremental - .can_read_mutations(IncrementalPasses::MODULE_CODEGEN); + .can_read_mutations(IncrementalPasses::MODULES_CODEGEN); let module_runtime_requirements_enabled = self .incremental - .can_read_mutations(IncrementalPasses::MODULE_RUNTIME_REQUIREMENTS); + .can_read_mutations(IncrementalPasses::MODULES_RUNTIME_REQUIREMENTS); let module_hashes_modules; let module_codegen_modules; let module_runtime_requirements_modules; diff --git a/crates/rspack_core/src/compiler/hmr.rs b/crates/rspack_core/src/compiler/hmr.rs index adc883a9c57..cc2080d7c37 100644 --- a/crates/rspack_core/src/compiler/hmr.rs +++ b/crates/rspack_core/src/compiler/hmr.rs @@ -105,27 +105,27 @@ impl Compiler { } if new_compilation .incremental - .can_read_mutations(IncrementalPasses::COLLECT_MODULES_DIAGNOSTICS) + .can_read_mutations(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS) { - new_compilation.modules_diagnostics = - std::mem::take(&mut self.compilation.modules_diagnostics); + new_compilation.dependencies_diagnostics = + std::mem::take(&mut self.compilation.dependencies_diagnostics); } if new_compilation .incremental - .can_read_mutations(IncrementalPasses::MODULE_HASHES) + .can_read_mutations(IncrementalPasses::MODULES_HASHES) { new_compilation.cgm_hash_results = std::mem::take(&mut self.compilation.cgm_hash_results); } if new_compilation .incremental - .can_read_mutations(IncrementalPasses::MODULE_CODEGEN) + .can_read_mutations(IncrementalPasses::MODULES_CODEGEN) { new_compilation.code_generation_results = std::mem::take(&mut self.compilation.code_generation_results); } if new_compilation .incremental - .can_read_mutations(IncrementalPasses::MODULE_RUNTIME_REQUIREMENTS) + .can_read_mutations(IncrementalPasses::MODULES_RUNTIME_REQUIREMENTS) { new_compilation.cgm_runtime_requirements_results = std::mem::take(&mut self.compilation.cgm_runtime_requirements_results); diff --git a/crates/rspack_core/src/unaffected_cache/incremental.rs b/crates/rspack_core/src/unaffected_cache/incremental.rs index b74b352a261..8f3e6b5fb7e 100644 --- a/crates/rspack_core/src/unaffected_cache/incremental.rs +++ b/crates/rspack_core/src/unaffected_cache/incremental.rs @@ -8,10 +8,10 @@ bitflags! { const MAKE = 1 << 0; const INFER_ASYNC_MODULES = 1 << 1; const PROVIDED_EXPORTS = 1 << 2; - const COLLECT_MODULES_DIAGNOSTICS = 1 << 3; - const MODULE_HASHES = 1 << 4; - const MODULE_CODEGEN = 1 << 5; - const MODULE_RUNTIME_REQUIREMENTS = 1 << 6; + const DEPENDENCIES_DIAGNOSTICS = 1 << 3; + const MODULES_HASHES = 1 << 4; + const MODULES_CODEGEN = 1 << 5; + const MODULES_RUNTIME_REQUIREMENTS = 1 << 6; const EMIT_ASSETS = 1 << 7; } } diff --git a/packages/rspack-test-tools/src/case/new-incremental.ts b/packages/rspack-test-tools/src/case/new-incremental.ts index 9e61562a989..8aa268659d7 100644 --- a/packages/rspack-test-tools/src/case/new-incremental.ts +++ b/packages/rspack-test-tools/src/case/new-incremental.ts @@ -82,16 +82,7 @@ const watchCreator = new BasicCaseCreator({ compilerType: ECompilerType.Rspack, configFiles: ["rspack.config.js", "webpack.config.js"], experiments: { - incremental: { - make: true, - emitAssets: true, - inferAsyncModules: true, - providedExports: true, - collectModulesDiagnostics: true, - moduleHashes: true, - moduleCodegen: true, - moduleRuntimeRequirements: true - } + incremental: true } }) : new WatchStepProcessor({ diff --git a/packages/rspack-test-tools/src/processor/hot-new-incremental.ts b/packages/rspack-test-tools/src/processor/hot-new-incremental.ts index 8f8751c444b..3461798587a 100644 --- a/packages/rspack-test-tools/src/processor/hot-new-incremental.ts +++ b/packages/rspack-test-tools/src/processor/hot-new-incremental.ts @@ -50,16 +50,7 @@ export class HotNewIncrementalProcessor< if (this._hotOptions.compilerType === ECompilerType.Rspack) { const rspackOptions = options as TCompilerOptions; rspackOptions.experiments ??= {}; - rspackOptions.experiments.incremental ??= { - make: true, - emitAssets: true, - inferAsyncModules: true, - providedExports: true, - collectModulesDiagnostics: true, - moduleHashes: true, - moduleCodegen: true, - moduleRuntimeRequirements: true - }; + rspackOptions.experiments.incremental ??= true; } else { throw new Error( "HotNewIncrementalProcessor should only used for Rspack." diff --git a/packages/rspack-test-tools/tests/__snapshots__/Defaults.test.js.snap b/packages/rspack-test-tools/tests/__snapshots__/Defaults.test.js.snap index 800f99f961c..634f737aaf4 100644 --- a/packages/rspack-test-tools/tests/__snapshots__/Defaults.test.js.snap +++ b/packages/rspack-test-tools/tests/__snapshots__/Defaults.test.js.snap @@ -20,13 +20,13 @@ Object { css: undefined, futureDefaults: false, incremental: Object { - collectModulesDiagnostics: false, + dependenciesDiagnostics: false, emitAssets: true, inferAsyncModules: false, make: true, - moduleCodegen: false, - moduleHashes: false, - moduleRuntimeRequirements: false, + modulesCodegen: false, + modulesHashes: false, + modulesRuntimeRequirements: false, providedExports: false, }, layers: false, diff --git a/packages/rspack/etc/core.api.md b/packages/rspack/etc/core.api.md index 54b9b81f86d..7c69f39a43e 100644 --- a/packages/rspack/etc/core.api.md +++ b/packages/rspack/etc/core.api.md @@ -1803,28 +1803,28 @@ const experiments_2: z.ZodObject<{ emitAssets: z.ZodOptional; inferAsyncModules: z.ZodOptional; providedExports: z.ZodOptional; - collectModulesDiagnostics: z.ZodOptional; - moduleHashes: z.ZodOptional; - moduleCodegen: z.ZodOptional; - moduleRuntimeRequirements: z.ZodOptional; + dependenciesDiagnostics: z.ZodOptional; + modulesHashes: z.ZodOptional; + modulesCodegen: z.ZodOptional; + modulesRuntimeRequirements: z.ZodOptional; }, "strict", z.ZodTypeAny, { make?: boolean | undefined; providedExports?: boolean | undefined; emitAssets?: boolean | undefined; inferAsyncModules?: boolean | undefined; - collectModulesDiagnostics?: boolean | undefined; - moduleHashes?: boolean | undefined; - moduleCodegen?: boolean | undefined; - moduleRuntimeRequirements?: boolean | undefined; + dependenciesDiagnostics?: boolean | undefined; + modulesHashes?: boolean | undefined; + modulesCodegen?: boolean | undefined; + modulesRuntimeRequirements?: boolean | undefined; }, { make?: boolean | undefined; providedExports?: boolean | undefined; emitAssets?: boolean | undefined; inferAsyncModules?: boolean | undefined; - collectModulesDiagnostics?: boolean | undefined; - moduleHashes?: boolean | undefined; - moduleCodegen?: boolean | undefined; - moduleRuntimeRequirements?: boolean | undefined; + dependenciesDiagnostics?: boolean | undefined; + modulesHashes?: boolean | undefined; + modulesCodegen?: boolean | undefined; + modulesRuntimeRequirements?: boolean | undefined; }>]>>; futureDefaults: z.ZodOptional; rspackFuture: z.ZodOptional; inferAsyncModules: z.ZodOptional; providedExports: z.ZodOptional; - collectModulesDiagnostics: z.ZodOptional; - moduleHashes: z.ZodOptional; - moduleCodegen: z.ZodOptional; - moduleRuntimeRequirements: z.ZodOptional; + dependenciesDiagnostics: z.ZodOptional; + modulesHashes: z.ZodOptional; + modulesCodegen: z.ZodOptional; + modulesRuntimeRequirements: z.ZodOptional; }, "strict", z.ZodTypeAny, { make?: boolean | undefined; providedExports?: boolean | undefined; emitAssets?: boolean | undefined; inferAsyncModules?: boolean | undefined; - collectModulesDiagnostics?: boolean | undefined; - moduleHashes?: boolean | undefined; - moduleCodegen?: boolean | undefined; - moduleRuntimeRequirements?: boolean | undefined; + dependenciesDiagnostics?: boolean | undefined; + modulesHashes?: boolean | undefined; + modulesCodegen?: boolean | undefined; + modulesRuntimeRequirements?: boolean | undefined; }, { make?: boolean | undefined; providedExports?: boolean | undefined; emitAssets?: boolean | undefined; inferAsyncModules?: boolean | undefined; - collectModulesDiagnostics?: boolean | undefined; - moduleHashes?: boolean | undefined; - moduleCodegen?: boolean | undefined; - moduleRuntimeRequirements?: boolean | undefined; + dependenciesDiagnostics?: boolean | undefined; + modulesHashes?: boolean | undefined; + modulesCodegen?: boolean | undefined; + modulesRuntimeRequirements?: boolean | undefined; }>; // @public @@ -5970,28 +5970,28 @@ export const rspackOptions: z.ZodObject<{ emitAssets: z.ZodOptional; inferAsyncModules: z.ZodOptional; providedExports: z.ZodOptional; - collectModulesDiagnostics: z.ZodOptional; - moduleHashes: z.ZodOptional; - moduleCodegen: z.ZodOptional; - moduleRuntimeRequirements: z.ZodOptional; + dependenciesDiagnostics: z.ZodOptional; + modulesHashes: z.ZodOptional; + modulesCodegen: z.ZodOptional; + modulesRuntimeRequirements: z.ZodOptional; }, "strict", z.ZodTypeAny, { make?: boolean | undefined; providedExports?: boolean | undefined; emitAssets?: boolean | undefined; inferAsyncModules?: boolean | undefined; - collectModulesDiagnostics?: boolean | undefined; - moduleHashes?: boolean | undefined; - moduleCodegen?: boolean | undefined; - moduleRuntimeRequirements?: boolean | undefined; + dependenciesDiagnostics?: boolean | undefined; + modulesHashes?: boolean | undefined; + modulesCodegen?: boolean | undefined; + modulesRuntimeRequirements?: boolean | undefined; }, { make?: boolean | undefined; providedExports?: boolean | undefined; emitAssets?: boolean | undefined; inferAsyncModules?: boolean | undefined; - collectModulesDiagnostics?: boolean | undefined; - moduleHashes?: boolean | undefined; - moduleCodegen?: boolean | undefined; - moduleRuntimeRequirements?: boolean | undefined; + dependenciesDiagnostics?: boolean | undefined; + modulesHashes?: boolean | undefined; + modulesCodegen?: boolean | undefined; + modulesRuntimeRequirements?: boolean | undefined; }>]>>; futureDefaults: z.ZodOptional; rspackFuture: z.ZodOptional { D(experiments.incremental, "emitAssets", true); D(experiments.incremental, "inferAsyncModules", false); D(experiments.incremental, "providedExports", false); - D(experiments.incremental, "collectModulesDiagnostics", false); - D(experiments.incremental, "moduleHashes", false); - D(experiments.incremental, "moduleCodegen", false); - D(experiments.incremental, "moduleRuntimeRequirements", false); + D(experiments.incremental, "dependenciesDiagnostics", false); + D(experiments.incremental, "modulesHashes", false); + D(experiments.incremental, "modulesCodegen", false); + D(experiments.incremental, "modulesRuntimeRequirements", false); } // IGNORE(experiments.rspackFuture): Rspack specific configuration D(experiments, "rspackFuture", {}); diff --git a/packages/rspack/src/config/normalization.ts b/packages/rspack/src/config/normalization.ts index fd3862cfa05..51992e3550d 100644 --- a/packages/rspack/src/config/normalization.ts +++ b/packages/rspack/src/config/normalization.ts @@ -312,7 +312,18 @@ export const getNormalizedRspackOptions = ( options => (options === true ? {} : options) ), incremental: optionalNestedConfig(experiments.incremental, options => - options === true ? {} : options + options === true + ? ({ + make: true, + emitAssets: true, + dependenciesDiagnostics: true, + inferAsyncModules: true, + providedExports: true, + modulesHashes: true, + modulesCodegen: true, + modulesRuntimeRequirements: true + } satisfies Incremental) + : options ) })), watch: config.watch, diff --git a/packages/rspack/src/config/zod.ts b/packages/rspack/src/config/zod.ts index ad0235b28ab..5b41cb111c5 100644 --- a/packages/rspack/src/config/zod.ts +++ b/packages/rspack/src/config/zod.ts @@ -1240,10 +1240,10 @@ const incremental = z.strictObject({ emitAssets: z.boolean().optional(), inferAsyncModules: z.boolean().optional(), providedExports: z.boolean().optional(), - collectModulesDiagnostics: z.boolean().optional(), - moduleHashes: z.boolean().optional(), - moduleCodegen: z.boolean().optional(), - moduleRuntimeRequirements: z.boolean().optional() + dependenciesDiagnostics: z.boolean().optional(), + modulesHashes: z.boolean().optional(), + modulesCodegen: z.boolean().optional(), + modulesRuntimeRequirements: z.boolean().optional() }); export type Incremental = z.infer;