Treeshake instanceof

src/ast/nodes/BinaryExpression.ts

@@ -2,22 +2,52 @@ import type MagicString from 'magic-string';
 import { BLANK } from '../../utils/blank';
 import type { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
 import type { DeoptimizableEntity } from '../DeoptimizableEntity';
-import type { HasEffectsContext } from '../ExecutionContext';
-import { INTERACTION_ACCESSED, NodeInteraction } from '../NodeInteractions';
+import type { HasEffectsContext, InclusionContext } from '../ExecutionContext';
+import { createHasEffectsContext } from '../ExecutionContext';
+import {
+	INTERACTION_ACCESSED,
+	NODE_INTERACTION_UNKNOWN_ASSIGNMENT,
+	NodeInteraction
+} from '../NodeInteractions';
 import {
 	EMPTY_PATH,
 	type ObjectPath,
 	type PathTracker,
-	SHARED_RECURSION_TRACKER
+	SHARED_RECURSION_TRACKER,
+	TEST_INCLUSION_PATH
 } from '../utils/PathTracker';
 import ExpressionStatement from './ExpressionStatement';
 import type { LiteralValue } from './Literal';
 import type * as NodeType from './NodeType';
 import { type LiteralValueOrUnknown, UnknownValue } from './shared/Expression';
-import { type ExpressionNode, NodeBase } from './shared/Node';
+import { type ExpressionNode, IncludeChildren, NodeBase } from './shared/Node';
+
+type Operator =
+	| '!='
+	| '!=='
+	| '%'
+	| '&'
+	| '*'
+	| '**'
+	| '+'
+	| '-'
+	| '/'
+	| '<'
+	| '<<'
+	| '<='
+	| '=='
+	| '==='
+	| '>'
+	| '>='
+	| '>>'
+	| '>>>'
+	| '^'
+	| '|'
+	| 'in'
+	| 'instanceof';
 
 const binaryOperators: {
-	[operator: string]: (left: LiteralValue, right: LiteralValue) => LiteralValueOrUnknown;
+	[operator in Operator]?: (left: LiteralValue, right: LiteralValue) => LiteralValueOrUnknown;
 } = {
 	'!=': (left, right) => left != right,
 	'!==': (left, right) => left !== right,
@@ -52,6 +82,7 @@ export default class BinaryExpression extends NodeBase implements DeoptimizableE
 	declare operator: keyof typeof binaryOperators;
 	declare right: ExpressionNode;
 	declare type: NodeType.tBinaryExpression;
+	private expressionsDependingOnNegativeInstanceof = new Set<DeoptimizableEntity>();
 
 	deoptimizeCache(): void {}
 
@@ -61,6 +92,19 @@ export default class BinaryExpression extends NodeBase implements DeoptimizableE
 		origin: DeoptimizableEntity
 	): LiteralValueOrUnknown {
 		if (path.length > 0) return UnknownValue;
+		if (this.operator === 'instanceof') {
+			if (
+				this.right.hasEffectsOnInteractionAtPath(
+					TEST_INCLUSION_PATH,
+					NODE_INTERACTION_UNKNOWN_ASSIGNMENT,
+					createHasEffectsContext()
+				)
+			) {
+				return UnknownValue;
+			}
+			this.expressionsDependingOnNegativeInstanceof.add(origin);
+			return false;
+		}
 		const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
 		if (typeof leftValue === 'symbol') return UnknownValue;
 
@@ -79,15 +123,25 @@ export default class BinaryExpression extends NodeBase implements DeoptimizableE
 			this.operator === '+' &&
 			this.parent instanceof ExpressionStatement &&
 			this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === ''
-		)
+		) {
 			return true;
+		}
+		this.deoptimizeInstanceof(context);
 		return super.hasEffects(context);
 	}
 
 	hasEffectsOnInteractionAtPath(path: ObjectPath, { type }: NodeInteraction): boolean {
 		return type !== INTERACTION_ACCESSED || path.length > 1;
 	}
 
+	// TODO Lukas if the operator is instanceof, only include if necessary
+	include(context: InclusionContext, includeChildrenRecursively: IncludeChildren) {
+		this.deoptimizeInstanceof();
+		if (!this.expressionsDependingOnNegativeInstanceof.size) {
+			super.include(context, includeChildrenRecursively);
+		}
+	}
+
 	render(
 		code: MagicString,
 		options: RenderOptions,
@@ -96,4 +150,21 @@ export default class BinaryExpression extends NodeBase implements DeoptimizableE
 		this.left.render(code, options, { renderedSurroundingElement });
 		this.right.render(code, options);
 	}
+
+	private deoptimizeInstanceof(context?: HasEffectsContext) {
+		if (
+			this.operator === 'instanceof' &&
+			this.expressionsDependingOnNegativeInstanceof.size &&
+			this.right.hasEffectsOnInteractionAtPath(
+				TEST_INCLUSION_PATH,
+				NODE_INTERACTION_UNKNOWN_ASSIGNMENT,
+				context || createHasEffectsContext()
+			)
+		) {
+			for (const expression of this.expressionsDependingOnNegativeInstanceof) {
+				expression.deoptimizeCache();
+			}
+			this.expressionsDependingOnNegativeInstanceof.clear();
+		}
+	}
 }

src/ast/nodes/shared/ObjectEntity.ts

@@ -11,6 +11,7 @@ import {
 	ObjectPath,
 	ObjectPathKey,
 	PathTracker,
+	TestInclusionKey,
 	UNKNOWN_INTEGER_PATH,
 	UNKNOWN_PATH,
 	UnknownInteger,
@@ -281,6 +282,7 @@ export class ObjectEntity extends ExpressionEntity {
 		context: HasEffectsContext
 	): boolean {
 		const [key, ...subPath] = path;
+		if (key === TestInclusionKey) return false;
 		if (subPath.length || interaction.type === INTERACTION_CALLED) {
 			const expressionAtPath = this.getMemberExpression(key);
 			if (expressionAtPath) {

src/ast/utils/PathTracker.ts

@@ -4,15 +4,23 @@ import type { Entity } from '../Entity';
 export const UnknownKey = Symbol('Unknown Key');
 export const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
 export const UnknownInteger = Symbol('Unknown Integer');
+/**
+ * A special key that does not actually reference a property but can be used to
+ * test if a variable is included via
+ * .hasEffectsOnInteractionAtPath([TestInclusionKey], {type: INTERACTION_ASSIGNED,...}, ...)
+ */
+export const TestInclusionKey = Symbol('Test Inclusion Key');
 export type ObjectPathKey =
 	| string
 	| typeof UnknownKey
 	| typeof UnknownNonAccessorKey
-	| typeof UnknownInteger;
+	| typeof UnknownInteger
+	| typeof TestInclusionKey;
 
 export type ObjectPath = ObjectPathKey[];
 export const EMPTY_PATH: ObjectPath = [];
 export const UNKNOWN_PATH: ObjectPath = [UnknownKey];
+export const TEST_INCLUSION_PATH: ObjectPath = [TestInclusionKey];
 // For deoptimizations, this means we are modifying an unknown property but did
 // not lose track of the object or are creating a setter/getter;
 // For assignment effects it means we do not check for setter/getter effects
@@ -25,6 +33,7 @@ const EntitiesKey = Symbol('Entities');
 interface EntityPaths {
 	[pathSegment: string]: EntityPaths;
 	[EntitiesKey]: Set<Entity>;
+	[TestInclusionKey]?: EntityPaths;
 	[UnknownInteger]?: EntityPaths;
 	[UnknownKey]?: EntityPaths;
 	[UnknownNonAccessorKey]?: EntityPaths;
@@ -72,6 +81,7 @@ export const SHARED_RECURSION_TRACKER = new PathTracker();
 interface DiscriminatedEntityPaths {
 	[pathSegment: string]: DiscriminatedEntityPaths;
 	[EntitiesKey]: Map<unknown, Set<Entity>>;
+	[TestInclusionKey]?: DiscriminatedEntityPaths;
 	[UnknownInteger]?: DiscriminatedEntityPaths;
 	[UnknownKey]?: DiscriminatedEntityPaths;
 	[UnknownNonAccessorKey]?: DiscriminatedEntityPaths;

test/form/samples/instanceof/_config.js

@@ -0,0 +1,3 @@
+module.exports = {
+	description: 'removes instanceof checks if the right side is not included'
+};

test/form/samples/instanceof/_expected.js

@@ -0,0 +1,3 @@
+console.log('retained');
+
+console.log('retained');

test/form/samples/instanceof/main.js

@@ -0,0 +1,17 @@
+class Unused1 {}
+class Used1 {}
+const Intermediate = Used1;
+
+if (new Intermediate() instanceof Unused1) console.log('removed');
+else console.log('retained');
+
+class Unused2 {}
+class WithEffect {
+	constructor() {
+		console.log('effect');
+	}
+}
+
+if (new WithEffect() instanceof Unused2)
+	console.log('does not matter, but effect should be retained');
+else console.log('retained');

test/form/samples/invalid-binary-expressions/_expected.js

@@ -37,7 +37,3 @@ if (null instanceof true) {
 if (null instanceof 'y') {
 	console.log('retained');
 }
-
-if (null instanceof {}) {
-	console.log('retained');
-}