feat: improve tree-shaking by propagate const parameter

src/Graph.ts

@@ -18,6 +18,7 @@ import { PluginDriver } from './utils/PluginDriver';
 import Queue from './utils/Queue';
 import { BuildPhase } from './utils/buildPhase';
 import { analyseModuleExecution } from './utils/executionOrder';
+import { functionParameterPass } from './utils/functionParameterPass';
 import { LOGLEVEL_WARN } from './utils/logging';
 import {
 	error,
@@ -160,6 +161,7 @@ export default class Graph {
 	}
 
 	private includeStatements(): void {
+		functionParameterPass(this.modules);
 		const entryModules = [...this.entryModules, ...this.implicitEntryModules];
 		for (const module of entryModules) {
 			markModuleAndImpureDependenciesAsExecuted(module);

src/ast/nodes/Identifier.ts

@@ -70,6 +70,7 @@ export default class Identifier extends NodeBase implements PatternNode {
 		if (!this.variable && isReference(this, this.parent as NodeWithFieldDefinition)) {
 			this.variable = this.scope.findVariable(this.name);
 			this.variable.addReference(this);
+			this.variable.addUsedPlace(this);
 		}
 	}
 

src/ast/nodes/MemberExpression.ts

@@ -156,6 +156,9 @@ export default class MemberExpression
 				this.isUndefined = true;
 			} else {
 				this.variable = resolvedVariable;
+				if (this.object instanceof Identifier) {
+					this.variable.addUsedPlace(this);
+				}
 				this.scope.addNamespaceMemberAccess(getStringFromPath(path!), resolvedVariable);
 			}
 		} else {

src/ast/variables/ExportDefaultVariable.ts

@@ -3,6 +3,7 @@ import ClassDeclaration from '../nodes/ClassDeclaration';
 import type ExportDefaultDeclaration from '../nodes/ExportDefaultDeclaration';
 import FunctionDeclaration from '../nodes/FunctionDeclaration';
 import Identifier, { type IdentifierWithVariable } from '../nodes/Identifier';
+import type { NodeBase } from '../nodes/shared/Node';
 import LocalVariable from './LocalVariable';
 import UndefinedVariable from './UndefinedVariable';
 import type Variable from './Variable';
@@ -37,6 +38,16 @@ export default class ExportDefaultVariable extends LocalVariable {
 		}
 	}
 
+	addUsedPlace(identifier: NodeBase): void {
+		const original = this.getOriginalVariable();
+		this.originalVariable = null;
+		if (original === this) {
+			super.addUsedPlace(identifier);
+		} else {
+			original.addUsedPlace(identifier);
+		}
+	}
+
 	forbidName(name: string) {
 		const original = this.getOriginalVariable();
 		if (original === this) {
@@ -57,6 +68,7 @@ export default class ExportDefaultVariable extends LocalVariable {
 
 	getDirectOriginalVariable(): Variable | null {
 		return this.originalId &&
+			this.originalId.variable &&
 			(this.hasId ||
 				!(
 					this.originalId.isPossibleTDZ() ||

src/ast/variables/ParameterVariable.ts

@@ -1,15 +1,18 @@
 import type { AstContext } from '../../Module';
 import { EMPTY_ARRAY } from '../../utils/blank';
+import type { DeoptimizableEntity } from '../DeoptimizableEntity';
 import type { NodeInteraction } from '../NodeInteractions';
 import { INTERACTION_CALLED } from '../NodeInteractions';
 import type ExportDefaultDeclaration from '../nodes/ExportDefaultDeclaration';
 import type Identifier from '../nodes/Identifier';
-import type { ExpressionEntity } from '../nodes/shared/Expression';
+import type { ExpressionEntity, LiteralValueOrUnknown } from '../nodes/shared/Expression';
 import {
 	deoptimizeInteraction,
 	UNKNOWN_EXPRESSION,
-	UNKNOWN_RETURN_EXPRESSION
+	UNKNOWN_RETURN_EXPRESSION,
+	UnknownValue
 } from '../nodes/shared/Expression';
+import type { ExpressionNode } from '../nodes/shared/Node';
 import type { ObjectPath, ObjectPathKey } from '../utils/PathTracker';
 import {
 	PathTracker,
@@ -71,6 +74,25 @@ export default class ParameterVariable extends LocalVariable {
 		}
 	}
 
+	knownValue: ExpressionNode | null = null;
+	setKnownValue(value: ExpressionNode): void {
+		this.knownValue = value;
+	}
+
+	getLiteralValueAtPath(
+		path: ObjectPath,
+		recursionTracker: PathTracker,
+		origin: DeoptimizableEntity
+	): LiteralValueOrUnknown {
+		if (this.isReassigned) {
+			return UnknownValue;
+		}
+		if (this.knownValue) {
+			return this.knownValue.getLiteralValueAtPath(path, recursionTracker, origin);
+		}
+		return UnknownValue;
+	}
+
 	deoptimizeArgumentsOnInteractionAtPath(interaction: NodeInteraction, path: ObjectPath): void {
 		// For performance reasons, we fully deoptimize all deeper interactions
 		if (

src/ast/variables/Variable.ts

@@ -6,6 +6,7 @@ import type { NodeInteraction } from '../NodeInteractions';
 import { INTERACTION_ACCESSED } from '../NodeInteractions';
 import type Identifier from '../nodes/Identifier';
 import { ExpressionEntity } from '../nodes/shared/Expression';
+import type { NodeBase } from '../nodes/shared/Node';
 import type { VariableKind } from '../nodes/shared/VariableKinds';
 import type { ObjectPath } from '../utils/PathTracker';
 
@@ -34,6 +35,12 @@ export default class Variable extends ExpressionEntity {
 	 */
 	addReference(_identifier: Identifier): void {}
 
+	AllUsedPlaces: NodeBase[] = [];
+
+	addUsedPlace(identifier: NodeBase): void {
+		this.AllUsedPlaces.push(identifier);
+	}
+
 	/**
 	 * Prevent this variable from being renamed to this name to avoid name
 	 * collisions

src/utils/functionParameterPass.ts

@@ -0,0 +1,104 @@
+import type Module from '../Module';
+import type CallExpression from '../ast/nodes/CallExpression';
+import type FunctionDeclaration from '../ast/nodes/FunctionDeclaration';
+import type { LiteralValue } from '../ast/nodes/Literal';
+import type { ExpressionNode } from '../ast/nodes/shared/Node';
+import { EMPTY_PATH, SHARED_RECURSION_TRACKER } from '../ast/utils/PathTracker';
+import LocalVariable from '../ast/variables/LocalVariable';
+import ParameterVariable from '../ast/variables/ParameterVariable';
+
+function collectTopLevelFunctionCalls(modules: Module[]) {
+	const topLevelFunctions = new Map<FunctionDeclaration, CallExpression[]>();
+	modules = modules.filter(module => module.dynamicImporters.length === 0);
+	for (const module of modules) {
+		const scope = module.scope.variables;
+		for (const [_, v] of scope) {
+			if (!(v instanceof LocalVariable) || v.kind !== 'function') continue;
+
+			const allUses = v.AllUsedPlaces;
+			if (allUses.length === 0) continue;
+
+			const containNonCallExpression = allUses.some(use => use.parent.type !== 'CallExpression');
+			if (containNonCallExpression) continue;
+
+			const function_ = v.declarations[0].parent as FunctionDeclaration;
+			if (function_.params.length === 0) continue;
+
+			const allParameterIsIdentifier = function_.params.every(
+				parameter =>
+					parameter.type === 'Identifier' && parameter.variable instanceof ParameterVariable
+			);
+			if (!allParameterIsIdentifier) continue;
+
+			if (allUses.length === 1) {
+				forwardFunctionUsedOnce(function_, allUses[0].parent as CallExpression);
+			} else {
+				topLevelFunctions.set(
+					function_,
+					allUses.map(use => use.parent as CallExpression)
+				);
+			}
+		}
+	}
+	return topLevelFunctions;
+}
+
+function forwardFunctionUsedOnce(function_: FunctionDeclaration, call: CallExpression) {
+	const maxLength = Math.min(function_.params.length, call.arguments.length);
+	for (let index = 0; index < maxLength; index++) {
+		const parameterVariable = function_.params[index].variable as ParameterVariable;
+		parameterVariable.setKnownValue(call.arguments[index] as ExpressionNode);
+	}
+}
+
+function setKnownLiteralValue(topLevelFunctions: Map<FunctionDeclaration, CallExpression[]>) {
+	let changed = false;
+	const deleteFunctions: Set<FunctionDeclaration> = new Set();
+
+	for (const [function_, calls] of topLevelFunctions) {
+		let parameterLength = function_.params.length;
+		for (const call of calls) {
+			parameterLength = Math.min(parameterLength, call.arguments.length);
+		}
+		for (let index = 0; index < parameterLength; index++) {
+			const parameter = function_.params[index];
+			const literalValues: LiteralValue[] = [];
+			let allLiteral = true;
+			for (const call of calls) {
+				const literal = call.arguments[index].getLiteralValueAtPath(
+					EMPTY_PATH,
+					SHARED_RECURSION_TRACKER,
+					call
+				);
+				if (typeof literal === 'symbol') {
+					allLiteral = false;
+					break;
+				}
+				literalValues.push(literal);
+			}
+
+			if (!allLiteral) continue;
+
+			const allSame = literalValues.every(literal => literal === literalValues[0]);
+			if (!allSame) continue;
+
+			changed = true;
+			deleteFunctions.add(function_);
+			const parameterVariable = parameter.variable as ParameterVariable;
+			parameterVariable.setKnownValue(calls[0].arguments[index] as ExpressionNode);
+		}
+	}
+
+	for (const function_ of deleteFunctions) {
+		topLevelFunctions.delete(function_);
+	}
+	return changed;
+}
+
+export function functionParameterPass(modules: Module[]) {
+	const topLevelFunctions = collectTopLevelFunctionCalls(modules);
+	let changed = true;
+	while (changed) {
+		changed = setKnownLiteralValue(topLevelFunctions);
+	}
+}

test/chunking-form/samples/missing-export-reused-deconflicting/_expected/amd/dep1.js

@@ -5,12 +5,13 @@ define(['exports'], (function (exports) { 'use strict';
 	console.log('This is the output when a missing export is used internally but not reexported');
 
 	function almostUseUnused(useIt) {
-		if (useIt) {
+		{
+			console.log(useIt);
 			console.log(_missingExportShim);
 		}
 	}
 
-	almostUseUnused(false);
+	almostUseUnused(true);
 
 	exports.missing1 = _missingExportShim;
 

test/chunking-form/samples/missing-export-reused-deconflicting/_expected/cjs/dep1.js

@@ -5,11 +5,12 @@ var _missingExportShim = void 0;
 console.log('This is the output when a missing export is used internally but not reexported');
 
 function almostUseUnused(useIt) {
-	if (useIt) {
+	{
+		console.log(useIt);
 		console.log(_missingExportShim);
 	}
 }
 
-almostUseUnused(false);
+almostUseUnused(true);
 
 exports.missing1 = _missingExportShim;

test/chunking-form/samples/missing-export-reused-deconflicting/_expected/es/dep1.js

@@ -3,11 +3,12 @@ var _missingExportShim = void 0;
 console.log('This is the output when a missing export is used internally but not reexported');
 
 function almostUseUnused(useIt) {
-	if (useIt) {
+	{
+		console.log(useIt);
 		console.log(_missingExportShim);
 	}
 }
 
-almostUseUnused(false);
+almostUseUnused(true);
 
 export { _missingExportShim as missing1 };

test/chunking-form/samples/missing-export-reused-deconflicting/_expected/system/dep1.js

@@ -8,12 +8,13 @@ System.register([], (function (exports) {
 			console.log('This is the output when a missing export is used internally but not reexported');
 
 			function almostUseUnused(useIt) {
-				if (useIt) {
+				{
+					console.log(useIt);
 					console.log(_missingExportShim);
 				}
 			}
 
-			almostUseUnused(false);
+			almostUseUnused(true);
 
 			exports("missing1", _missingExportShim);
 

test/chunking-form/samples/missing-export-reused-deconflicting/dep1.js

@@ -2,8 +2,9 @@ console.log('This is the output when a missing export is used internally but not
 
 function almostUseUnused(useIt) {
 	if (useIt) {
+		console.log(useIt);
 		console.log(_missingExportShim);
 	}
 }
 
-almostUseUnused(false);
+almostUseUnused(true);

test/chunking-form/samples/preserve-modules-commonjs/_expected/amd/_virtual/_commonjsHelpers.js

@@ -1,7 +1,7 @@
 define(['exports'], (function (exports) { 'use strict';
 
 	function getDefaultExportFromCjs (x) {
-		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+		return x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 	}
 
 	exports.getDefaultExportFromCjs = getDefaultExportFromCjs;

test/chunking-form/samples/preserve-modules-commonjs/_expected/cjs/_virtual/_commonjsHelpers.js

@@ -1,7 +1,7 @@
 'use strict';
 
 function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	return x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
 exports.getDefaultExportFromCjs = getDefaultExportFromCjs;

test/chunking-form/samples/preserve-modules-commonjs/_expected/es/_virtual/_commonjsHelpers.js

@@ -1,5 +1,5 @@
 function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	return x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
 export { getDefaultExportFromCjs };

test/chunking-form/samples/preserve-modules-commonjs/_expected/system/_virtual/_commonjsHelpers.js

@@ -6,7 +6,7 @@ System.register([], (function (exports) {
 			exports("getDefaultExportFromCjs", getDefaultExportFromCjs);
 
 			function getDefaultExportFromCjs (x) {
-				return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+				return x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 			}
 
 		})

test/form/samples/deopt-string-concatenation/_expected.js

@@ -9,3 +9,4 @@ function parseInt(str, radix) {
 }
 
 console.log(parseInt('1'));
+console.log(parseInt(Symbol('1')));

test/form/samples/deopt-string-concatenation/main.js

@@ -9,3 +9,4 @@ function parseInt(str, radix) {
 }
 
 console.log(parseInt('1'));
+console.log(parseInt(Symbol('1')));

test/form/samples/side-effects-return-statements/_expected/amd.js

@@ -8,5 +8,6 @@ define((function () { 'use strict';
 	}
 
 	assert.equal( isUsed( true ), 2 );
+	assert.equal( isUsed( false ), 1 );
 
 }));

test/form/samples/side-effects-return-statements/_expected/cjs.js

@@ -8,3 +8,4 @@ function isUsed ( x ) {
 }
 
 assert.equal( isUsed( true ), 2 );
+assert.equal( isUsed( false ), 1 );

test/form/samples/side-effects-return-statements/_expected/es.js

@@ -6,3 +6,4 @@ function isUsed ( x ) {
 }
 
 assert.equal( isUsed( true ), 2 );
+assert.equal( isUsed( false ), 1 );

test/form/samples/side-effects-return-statements/_expected/iife.js

@@ -9,5 +9,6 @@
 	}
 
 	assert.equal( isUsed( true ), 2 );
+	assert.equal( isUsed( false ), 1 );
 
 })();

test/form/samples/side-effects-return-statements/_expected/system.js

@@ -11,6 +11,7 @@ System.register('myBundle', [], (function () {
 			}
 
 			assert.equal( isUsed( true ), 2 );
+			assert.equal( isUsed( false ), 1 );
 
 		})
 	};

test/form/samples/side-effects-return-statements/_expected/umd.js

@@ -11,5 +11,6 @@
 	}
 
 	assert.equal( isUsed( true ), 2 );
+	assert.equal( isUsed( false ), 1 );
 
 }));