fix: alias sequence order & merge result (#9206)

crates/node_binding/binding.d.ts

@@ -116,7 +116,7 @@ export declare class JsCompilation {
   emitAsset(filename: string, source: JsCompatSource, assetInfo: JsAssetInfo): void
   deleteAsset(filename: string): void
   renameAsset(filename: string, newName: string): void
-  get entrypoints(): Record<string, JsChunkGroup>
+  get entrypoints(): JsChunkGroup[]
   get chunkGroups(): JsChunkGroup[]
   get hash(): string | null
   dependencies(): JsDependencies

crates/rspack_binding_values/src/compilation/mod.rs

@@ -378,20 +378,15 @@ impl JsCompilation {
     Ok(())
   }
 
-  #[napi(getter, ts_return_type = "Record<string, JsChunkGroup>")]
-  pub fn entrypoints(&self) -> Result<HashMap<&String, JsChunkGroupWrapper>> {
+  #[napi(getter, ts_return_type = "JsChunkGroup[]")]
+  pub fn entrypoints(&self) -> Result<Vec<JsChunkGroupWrapper>> {
     let compilation = self.as_ref()?;
 
     Ok(
       compilation
         .entrypoints()
-        .iter()
-        .map(|(n, _)| {
-          (
-            n,
-            JsChunkGroupWrapper::new(compilation.entrypoint_by_name(n).ukey, compilation),
-          )
-        })
+        .values()
+        .map(|ukey| JsChunkGroupWrapper::new(*ukey, compilation))
         .collect(),
     )
   }

crates/rspack_core/src/options/resolve/clever_merge.rs

@@ -158,10 +158,10 @@ fn parse_resolve(resolve: Resolve) -> ResolveWithEntry {
 
 fn overwrite<T, F>(a: Option<T>, b: Option<T>, f: F) -> Option<T>
 where
-  F: FnOnce(&T, T) -> T,
+  F: FnOnce(T, T) -> T,
 {
   match (a, b) {
-    (Some(a), Some(b)) => Some(f(&a, b)),
+    (Some(a), Some(b)) => Some(f(a, b)),
     (Some(a), None) => Some(a),
     (None, Some(b)) => Some(b),
     (None, None) => None,
@@ -268,7 +268,7 @@ fn _merge_resolve(first: Resolve, second: Resolve) -> Resolve {
       extensions,
       second.extensions.base.get_value_type(),
       need_merge_base,
-      |a, b| normalize_string_array(a, b)
+      normalize_string_array
     ),
     prefer_relative: merge!(
       prefer_relative,
@@ -292,25 +292,25 @@ fn _merge_resolve(first: Resolve, second: Resolve) -> Resolve {
       main_files,
       second.main_files.base.get_value_type(),
       need_merge_base,
-      |a, b| normalize_string_array(a, b)
+      normalize_string_array
     ),
     main_fields: merge!(
       main_fields,
       second.main_fields.base.get_value_type(),
       need_merge_base,
-      |a, b| normalize_string_array(a, b)
+      normalize_string_array
     ),
     condition_names: merge!(
       condition_names,
       second.condition_names.base.get_value_type(),
       need_merge_base,
-      |a, b| normalize_string_array(a, b)
+      normalize_string_array
     ),
     modules: merge!(
       modules,
       second.modules.base.get_value_type(),
       need_merge_base,
-      |a, b| normalize_string_array(a, b)
+      normalize_string_array
     ),
     fully_specified: merge!(
       fully_specified,
@@ -326,7 +326,7 @@ fn _merge_resolve(first: Resolve, second: Resolve) -> Resolve {
       description_files,
       second.description_files.base.get_value_type(),
       need_merge_base,
-      |a, b| normalize_string_array(a, b)
+      normalize_string_array
     ),
     enforce_extension: merge!(
       enforce_extension,
@@ -443,31 +443,37 @@ fn _merge_resolve(first: Resolve, second: Resolve) -> Resolve {
   }
 }
 
-fn normalize_string_array(a: &[String], b: Vec<String>) -> Vec<String> {
+fn normalize_string_array(a: Vec<String>, b: Vec<String>) -> Vec<String> {
   b.into_iter().fold(vec![], |mut acc, item| {
     if item.eq("...") {
-      acc.append(&mut a.to_vec());
+      acc.append(&mut a.clone());
     } else {
       acc.push(item);
     }
     acc
   })
 }
 
-fn extend_alias(a: &Alias, b: Alias) -> Alias {
-  let mut b = b;
-  // FIXME: I think this clone can be removed
-  b.extend(a.clone());
-  b.dedup();
-  b
+fn extend_alias(mut a: Alias, b: Alias) -> Alias {
+  for (key, value) in b {
+    if let Some((_, v)) = a.iter_mut().find(|(k, _)| *k == key) {
+      *v = value;
+    } else {
+      a.push((key, value));
+    }
+  }
+  a
 }
 
-fn extend_extension_alias(a: &ExtensionAlias, b: ExtensionAlias) -> ExtensionAlias {
-  let mut b = b;
-  // FIXME: I think this clone can be removed
-  b.extend(a.clone());
-  b.dedup();
-  b
+fn extend_extension_alias(mut a: ExtensionAlias, b: ExtensionAlias) -> ExtensionAlias {
+  for (key, value) in b {
+    if let Some((_, v)) = a.iter_mut().find(|(k, _)| *k == key) {
+      *v = value;
+    } else {
+      a.push((key, value));
+    }
+  }
+  a
 }
 
 #[cfg(test)]
@@ -636,8 +642,8 @@ mod test {
     assert_eq!(
       options.alias.expect("should be Ok"),
       vec![
-        ("c2".to_string(), vec![AliasMap::Ignore]),
-        ("c".to_string(), vec![AliasMap::Ignore])
+        ("c".to_string(), vec![AliasMap::Ignore]),
+        ("c2".to_string(), vec![AliasMap::Ignore])
       ]
     );
     assert_eq!(options.condition_names.expect("should be Ok").len(), 3);

packages/rspack-test-tools/tests/configCases/compilation/entrypoints/bar.js

@@ -0,0 +1 @@
+Math.random();

packages/rspack-test-tools/tests/configCases/compilation/entrypoints/foo.js

@@ -0,0 +1 @@
+Math.random();

packages/rspack-test-tools/tests/configCases/compilation/entrypoints/index.js

@@ -0,0 +1 @@
+Math.random();

packages/rspack-test-tools/tests/configCases/compilation/entrypoints/rspack.config.js

@@ -0,0 +1,36 @@
+const PLUGIN_NAME = "plugin";
+
+class Plugin {
+    /**
+     * @param {import("@rspack/core").Compiler} compiler
+     */
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
+                expect(Array.from(compilation.entrypoints.keys())).toEqual([]);
+            });
+
+            compilation.hooks.afterProcessAssets.tap(PLUGIN_NAME, () => {
+                expect(Array.from(compilation.entrypoints.keys())).toEqual(["main", "foo", "bar"]);
+            })
+        });
+    }
+}
+
+/**@type {import("@rspack/core").Configuration}*/
+module.exports = {
+    entry: {
+        main: {
+            import: "./index.js",
+        },
+        foo: {
+            import: "./foo.js",
+            asyncChunks: true
+        },
+        bar: {
+            import: "./bar.js",
+            asyncChunks: true
+        },
+    },
+    plugins: [new Plugin()]
+};

packages/rspack-test-tools/tests/configCases/module/alias-sequence-merge/exist.js

@@ -0,0 +1 @@
+export const foo = "foo";

packages/rspack-test-tools/tests/configCases/module/alias-sequence-merge/index.js

@@ -0,0 +1 @@
+require("foo");

packages/rspack-test-tools/tests/configCases/module/alias-sequence-merge/rspack.config.js

@@ -0,0 +1,23 @@
+/**
+ * @type {import('@rspack/core').RspackOptions}
+ */
+module.exports = {
+    module: {
+        rules: [
+            {
+                resolve: {
+                    alias: {
+                        "foo": "./not-exist"
+                    }
+                },
+            },
+            {
+                resolve: {
+                    alias: {
+                        "foo": "./exist"
+                    }
+                },
+            },
+        ]
+    },
+};

packages/rspack-test-tools/tests/configCases/module/alias-sequence-order/exist.js

@@ -0,0 +1 @@
+export const foo = "foo";

packages/rspack-test-tools/tests/configCases/module/alias-sequence-order/index.js

@@ -0,0 +1 @@
+require("foo/bar");

packages/rspack-test-tools/tests/configCases/module/alias-sequence-order/rspack.config.js

@@ -0,0 +1,23 @@
+/**
+ * @type {import('@rspack/core').RspackOptions}
+ */
+module.exports = {
+    module: {
+        rules: [
+            {
+                resolve: {
+                    alias: {
+                        "foo/bar": "./exist"
+                    }
+                },
+            },
+            {
+                resolve: {
+                    alias: {
+                        "foo": "./not-exist"
+                    }
+                },
+            },
+        ]
+    },
+};

packages/rspack/src/Compilation.ts

@@ -58,7 +58,6 @@ import { createReadonlyMap } from "./util/createReadonlyMap";
 import { createFakeCompilationDependencies } from "./util/fake";
 import type { InputFileSystem } from "./util/fs";
 import type Hash from "./util/hash";
-import { memoizeValue } from "./util/memoize";
 import { JsSource } from "./util/source";
 export type { AssetInfo } from "./util/AssetInfo";
 
@@ -399,27 +398,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * Get a map of all assets.
 	 */
 	get assets(): Record<string, Source> {
-		return memoizeValue(() => this.#createCachedAssets());
+		return this.#createCachedAssets();
 	}
 
 	/**
 	 * Get a map of all entrypoints.
 	 */
 	get entrypoints(): ReadonlyMap<string, Entrypoint> {
-		return memoizeValue(
-			() =>
-				new Map(
-					Object.entries(this.#inner.entrypoints).map(([n, e]) => [
-						n,
-						Entrypoint.__from_binding(e)
-					])
-				)
+		return new Map(
+			this.#inner.entrypoints.map(binding => {
+				const entrypoint = Entrypoint.__from_binding(binding);
+				return [entrypoint.name!, entrypoint];
+			})
 		);
 	}
 
 	get chunkGroups(): ReadonlyArray<ChunkGroup> {
-		return memoizeValue(() =>
-			this.#inner.chunkGroups.map(binding => ChunkGroup.__from_binding(binding))
+		return this.#inner.chunkGroups.map(binding =>
+			ChunkGroup.__from_binding(binding)
 		);
 	}
 
@@ -456,7 +452,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	get chunks(): ReadonlySet<Chunk> {
-		return memoizeValue(() => new Set(this.__internal__getChunks()));
+		return new Set(this.__internal__getChunks());
 	}
 
 	/**