refactor(types): remove @ts-expect-error in loaderRunner and StatsFac…

…tory (#7864)

* chore: ts

* chore: remove more ts-expect-error

* chore: adopt suggestions

* chore: refactor getResolve type

packages/rspack/etc/api.md

@@ -3295,7 +3295,7 @@ export class EnvironmentPlugin {
 }
 
 // @public (undocumented)
-type ErrorWithDetail = Error & {
+type ErrorWithDetails = Error & {
     details?: string;
 };
 
@@ -4511,10 +4511,10 @@ interface GlobalPassOption {
 type GotHandler<T = any> = (result: any | null, callback: (error: Error | null) => void) => void;
 
 // @public (undocumented)
-type GroupConfig = {
+type GroupConfig<T, R = T> = {
     getKeys: (arg0: any) => string[] | undefined;
-    createGroup: <T, R>(arg0: string, arg1: (T | R)[], arg2: T[]) => R;
-    getOptions?: (<T>(arg0: string, arg1: T[]) => GroupOptions) | undefined;
+    createGroup: (key: string, arg1: (T | R)[], arg2: T[]) => R;
+    getOptions?: ((key: string, arg1: T[]) => GroupOptions) | undefined;
 };
 
 // @public
@@ -4577,7 +4577,7 @@ type Hooks = Readonly<{
     extract: HookMap<SyncBailHook<[Object, any, StatsFactoryContext], undefined>>;
     filter: HookMap<SyncBailHook<[any, StatsFactoryContext, number, number], undefined>>;
     filterSorted: HookMap<SyncBailHook<[any, StatsFactoryContext, number, number], undefined>>;
-    groupResults: HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext], undefined>>;
+    groupResults: HookMap<SyncBailHook<[GroupConfig<any>[], StatsFactoryContext], undefined>>;
     filterResults: HookMap<SyncBailHook<[any, StatsFactoryContext, number, number], undefined>>;
     sort: HookMap<SyncBailHook<[
     ((arg1: any, arg2: any) => number)[],
@@ -5892,11 +5892,11 @@ export interface LoaderContext<OptionsType = {}> {
     // (undocumented)
     addMissingDependency(missing: string): void;
     // (undocumented)
-    async(): (err?: Error | null, content?: string | Buffer, sourceMap?: string | SourceMap, additionalData?: AdditionalData) => void;
+    async(): LoaderContextCallback;
     // (undocumented)
     cacheable(cacheable?: boolean): void;
     // (undocumented)
-    callback(err?: Error | null, content?: string | Buffer, sourceMap?: string | SourceMap, additionalData?: AdditionalData): void;
+    callback: LoaderContextCallback;
     // (undocumented)
     clearDependencies(): void;
     // (undocumented)
@@ -5930,7 +5930,7 @@ export interface LoaderContext<OptionsType = {}> {
     // (undocumented)
     getOptions(schema?: any): OptionsType;
     // (undocumented)
-    getResolve(options: Resolve): (context: any, request: any, callback: any) => Promise<any>;
+    getResolve(options: Resolve): ((context: string, request: string, callback: ResolveCallback) => void) | ((context: string, request: string) => Promise<string | false | undefined>);
     // (undocumented)
     hot?: boolean;
     // (undocumented)
@@ -5980,6 +5980,9 @@ export interface LoaderContext<OptionsType = {}> {
     version: 2;
 }
 
+// @public (undocumented)
+type LoaderContextCallback = (err?: Error | null, content?: string | Buffer, sourceMap?: string | SourceMap, additionalData?: AdditionalData) => void;
+
 // @public (undocumented)
 export type LoaderDefinition<OptionsType = {}, ContextAdditions = {}> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
     raw?: false;
@@ -9821,6 +9824,9 @@ export type ResolveAlias = z.infer<typeof resolveAlias>;
 // @public (undocumented)
 const resolveAlias: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<false>, z.ZodString]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>, "many">]>>;
 
+// @public (undocumented)
+type ResolveCallback = (err: null | ErrorWithDetails, res?: string | false, req?: ResolveRequest) => void;
+
 // @public (undocumented)
 type ResolveContext = {};
 
@@ -9861,7 +9867,7 @@ class Resolver {
     // (undocumented)
     binding: binding.JsResolver;
     // (undocumented)
-    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: (err: null | ErrorWithDetail, res?: string | false) => void): void;
+    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void;
     // (undocumented)
     resolveSync(context: object, path: string, request: string): string | false;
     // (undocumented)

packages/rspack/src/Resolver.ts

@@ -1,10 +1,12 @@
 import type * as binding from "@rspack/binding";
 import { type Resolve, getRawResolve } from "./config";
+import type {
+	ErrorWithDetails,
+	ResolveCallback
+} from "./config/adapterRuleUse";
 
 type ResolveContext = {};
 
-type ErrorWithDetail = Error & { details?: string };
-
 type ResolveOptionsWithDependencyType = Resolve & {
 	dependencyCategory?: string;
 	resolveToContext?: boolean;
@@ -30,17 +32,13 @@ export class Resolver {
 		path: string,
 		request: string,
 		resolveContext: ResolveContext,
-		callback: (
-			err: null | ErrorWithDetail,
-			res?: string | false
-			// req?: ResolveRequest
-		) => void
+		callback: ResolveCallback
 	): void {
 		try {
 			const res = this.binding.resolveSync(path, request);
 			callback(null, res);
 		} catch (err) {
-			callback(err as ErrorWithDetail);
+			callback(err as ErrorWithDetails);
 		}
 	}
 

packages/rspack/src/config/adapterRuleUse.ts

@@ -50,24 +50,30 @@ export interface AdditionalData {
 	[index: string]: any;
 }
 
+export type LoaderContextCallback = (
+	err?: Error | null,
+	content?: string | Buffer,
+	sourceMap?: string | SourceMap,
+	additionalData?: AdditionalData
+) => void;
+
+export type ErrorWithDetails = Error & { details?: string };
+
+// aligned with https://github.com/webpack/webpack/blob/64e8e33151c3fabd3f1917851193e458a526e803/declarations/LoaderContext.d.ts#L19
+export type ResolveCallback = (
+	err: null | ErrorWithDetails,
+	res?: string | false,
+	req?: ResolveRequest
+) => void;
+
 export interface LoaderContext<OptionsType = {}> {
 	version: 2;
 	resource: string;
 	resourcePath: string;
 	resourceQuery: string;
 	resourceFragment: string;
-	async(): (
-		err?: Error | null,
-		content?: string | Buffer,
-		sourceMap?: string | SourceMap,
-		additionalData?: AdditionalData
-	) => void;
-	callback(
-		err?: Error | null,
-		content?: string | Buffer,
-		sourceMap?: string | SourceMap,
-		additionalData?: AdditionalData
-	): void;
+	async(): LoaderContextCallback;
+	callback: LoaderContextCallback;
 	cacheable(cacheable?: boolean): void;
 	sourceMap: boolean;
 	rootContext: string;
@@ -114,7 +120,12 @@ export interface LoaderContext<OptionsType = {}> {
 	): void;
 	getResolve(
 		options: Resolve
-	): (context: any, request: any, callback: any) => Promise<any>;
+	):
+		| ((context: string, request: string, callback: ResolveCallback) => void)
+		| ((
+				context: string,
+				request: string
+		  ) => Promise<string | false | undefined>);
 	getLogger(name: string): Logger;
 	emitError(error: Error): void;
 	emitWarning(warning: Error): void;

packages/rspack/src/loader-runner/index.ts

@@ -33,6 +33,7 @@ import { NonErrorEmittedError, type RspackError } from "../RspackError";
 import {
 	BUILTIN_LOADER_PREFIX,
 	type LoaderContext,
+	type LoaderContextCallback,
 	isUseSimpleSourceMap,
 	isUseSourceMap
 } from "../config/adapterRuleUse";
@@ -236,45 +237,44 @@ const runSyncOrAsync = promisify(function runSyncOrAsync(
 	fn: Function,
 	context: LoaderContext,
 	args: any[],
-	callback: (err: Error | null, args: any[]) => void
+	callback: (err: Error | null | undefined, args: any[]) => void
 ) {
 	let isSync = true;
 	let isDone = false;
 	let isError = false; // internal error
 	let reportedError = false;
-	// @ts-expect-error loader-runner leverages `arguments` to achieve the same functionality.
 	context.async = function async() {
 		if (isDone) {
-			if (reportedError) return; // ignore
+			if (reportedError) return undefined as any; // ignore
 			throw new Error("async(): The callback was already called.");
 		}
 		isSync = false;
 		return innerCallback;
 	};
-	const innerCallback = (context.callback = (err, ...args) => {
+	const innerCallback: LoaderContextCallback = (err, ...args) => {
 		if (isDone) {
 			if (reportedError) return; // ignore
 			throw new Error("callback(): The callback was already called.");
 		}
 		isDone = true;
 		isSync = false;
 		try {
-			// @ts-expect-error
 			callback(err, args);
 		} catch (e) {
 			isError = true;
 			throw e;
 		}
-	});
+	};
+	context.callback = innerCallback;
+
 	try {
 		const result = (function LOADER_EXECUTION() {
 			return fn.apply(context, args);
 		})();
 		if (isSync) {
 			isDone = true;
 			if (result === undefined) {
-				// @ts-expect-error
-				callback();
+				callback(null, []);
 				return;
 			}
 			if (
@@ -306,8 +306,7 @@ const runSyncOrAsync = promisify(function runSyncOrAsync(
 		}
 		isDone = true;
 		reportedError = true;
-		// @ts-expect-error
-		callback(e);
+		callback(e as Error, []);
 	}
 });
 
@@ -585,26 +584,27 @@ export async function runLoaders(
 	loaderContext.resolve = function resolve(context, request, callback) {
 		resolver.resolve({}, context, request, getResolveContext(), callback);
 	};
-	// @ts-expect-error TODO
+
 	loaderContext.getResolve = function getResolve(options) {
 		const child = options ? resolver.withOptions(options as any) : resolver;
 		return (context, request, callback) => {
 			if (callback) {
 				child.resolve({}, context, request, getResolveContext(), callback);
-			} else {
-				return new Promise((resolve, reject) => {
-					child.resolve(
-						{},
-						context,
-						request,
-						getResolveContext(),
-						(err, result) => {
-							if (err) reject(err);
-							else resolve(result);
-						}
-					);
-				});
+				return;
 			}
+			// TODO: (type) our native resolver return value is "string | false" but webpack type is "string"
+			return new Promise<string | false | undefined>((resolve, reject) => {
+				child.resolve(
+					{},
+					context,
+					request,
+					getResolveContext(),
+					(err, result) => {
+						if (err) reject(err);
+						else resolve(result);
+					}
+				);
+			});
 		};
 	};
 	loaderContext.getLogger = function getLogger(name) {
@@ -651,7 +651,7 @@ export async function runLoaders(
 		sourceMap?,
 		assetInfo?
 	) {
-		let source: Source;
+		let source: Source | undefined = undefined;
 		if (sourceMap) {
 			if (
 				typeof sourceMap === "string" &&
@@ -679,13 +679,10 @@ export async function runLoaders(
 				content
 			);
 		}
-		// @ts-expect-error
-		compiler._lastCompilation.__internal__emit_asset_from_loader(
+		compiler._lastCompilation!.__internal__emit_asset_from_loader(
 			name,
-			// @ts-expect-error
-			source,
-			// @ts-expect-error
-			assetInfo,
+			source!,
+			assetInfo!,
 			context._moduleIdentifier
 		);
 	};

packages/rspack/src/node/NodeEnvironmentPlugin.ts

@@ -7,8 +7,8 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-// @ts-expect-error
-import CachedInputFileSystem from "enhanced-resolve/lib/CachedInputFileSystem";
+// @ts-expect-error we directly import from enhanced-resolve inner js file to improve performance
+import CachedInputFileSystem from "enhanced-resolve/lib/CachedInputFileSystem.js";
 import fs from "graceful-fs";
 
 import type { Compiler } from "..";