Class LogicalExpression

src/ast/nodes/LogicalExpression.ts:43–291

export type LogicalOperator = '||' | '&&' | '??';

export default class LogicalExpression extends NodeBase implements DeoptimizableEntity {
	declare left: ExpressionNode;
	declare operator: LogicalOperator;
	declare right: ExpressionNode;
	declare type: NodeType.tLogicalExpression;

	//private isBranchResolutionAnalysed = false;
	private get isBranchResolutionAnalysed(): boolean {
		return isFlagSet(this.flags, Flag.isBranchResolutionAnalysed);
	}
	private set isBranchResolutionAnalysed(value: boolean) {
		this.flags = setFlag(this.flags, Flag.isBranchResolutionAnalysed, value);
	}

	// We collect deoptimization information if usedBranch !== null
	private expressionsToBeDeoptimized: DeoptimizableEntity[] = [];
	private usedBranch: ExpressionNode | null = null;

	private get hasDeoptimizedCache(): boolean {
		return isFlagSet(this.flags, Flag.hasDeoptimizedCache);
	}
	private set hasDeoptimizedCache(value: boolean) {
		this.flags = setFlag(this.flags, Flag.hasDeoptimizedCache, value);
	}

	deoptimizeArgumentsOnInteractionAtPath(
		interaction: NodeInteraction,
		path: ObjectPath,
		recursionTracker: EntityPathTracker
	): void {
		this.left.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
		this.right.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
	}

	deoptimizeCache(): void {
		if (this.hasDeoptimizedCache) return;
		this.hasDeoptimizedCache = true;
		if (this.usedBranch) {
			const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
			this.usedBranch = null;
			unusedBranch.deoptimizePath(UNKNOWN_PATH);
			if (this.included) {
				// As we are not tracking inclusions, we just include everything
				unusedBranch.includePath(UNKNOWN_PATH, createInclusionContext());
			}
		}
		const {
			scope: { context },
			expressionsToBeDeoptimized
		} = this;
		this.expressionsToBeDeoptimized = EMPTY_ARRAY as unknown as DeoptimizableEntity[];
		for (const expression of expressionsToBeDeoptimized) {
			expression.deoptimizeCache();
		}
		// Request another pass because we need to ensure "include" runs again if
		// it is rendered
		context.requestTreeshakingPass();
	}