From c856ea203247228624357ec7a95bb4b3190e571f Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Mon, 27 Oct 2025 15:43:36 +0100
Subject: [PATCH] tidy up

---
 .../src/compiler/phases/2-analyze/index.js    | 330 +++++++++---------
 .../3-transform/client/transform-client.js    |   2 -
 .../client/visitors/ImportDeclaration.js      |  17 -
 .../3-transform/client/visitors/Program.js    |   7 +-
 .../3-transform/server/visitors/Program.js    |   7 +-
 .../3-transform/shared/transform-async.js     |   9 +-
 6 files changed, 174 insertions(+), 198 deletions(-)
 delete mode 100644 packages/svelte/src/compiler/phases/3-transform/client/visitors/ImportDeclaration.js

diff --git a/packages/svelte/src/compiler/phases/2-analyze/index.js b/packages/svelte/src/compiler/phases/2-analyze/index.js
index 7b484f1adb..7267203a1c 100644
--- a/packages/svelte/src/compiler/phases/2-analyze/index.js
+++ b/packages/svelte/src/compiler/phases/2-analyze/index.js
@@ -687,203 +687,203 @@ export function analyze_component(root, source, options) {
 		}
 	}
 
-	if (analysis.runes) {
-		const props_refs = module.scope.references.get('$$props');
-		if (props_refs) {
-			e.legacy_props_invalid(props_refs[0].node);
-		}
-
-		const rest_props_refs = module.scope.references.get('$$restProps');
-		if (rest_props_refs) {
-			e.legacy_rest_props_invalid(rest_props_refs[0].node);
-		}
-
-		/**
-		 * @param {ESTree.Node} expression
-		 * @param {Scope} scope
-		 * @param {Set<Binding>} touched
-		 * @param {Set<ESTree.Node>} seen
-		 */
-		const touch = (expression, scope, touched, seen = new Set()) => {
-			if (seen.has(expression)) return;
-			seen.add(expression);
-
-			walk(
-				expression,
-				{ scope },
-				{
-					ImportDeclaration(node) {},
-					Identifier(node, context) {
-						const parent = /** @type {ESTree.Node} */ (context.path.at(-1));
-						if (is_reference(node, parent)) {
-							const binding = context.state.scope.get(node.name);
-							if (binding) {
-								touched.add(binding);
-
-								for (const assignment of binding.assignments) {
-									touch(assignment.value, assignment.scope, touched, seen);
-								}
+	/**
+	 * @param {ESTree.Node} expression
+	 * @param {Scope} scope
+	 * @param {Set<Binding>} touched
+	 * @param {Set<ESTree.Node>} seen
+	 */
+	const touch = (expression, scope, touched, seen = new Set()) => {
+		if (seen.has(expression)) return;
+		seen.add(expression);
+
+		walk(
+			expression,
+			{ scope },
+			{
+				ImportDeclaration(node) {},
+				Identifier(node, context) {
+					const parent = /** @type {ESTree.Node} */ (context.path.at(-1));
+					if (is_reference(node, parent)) {
+						const binding = context.state.scope.get(node.name);
+						if (binding) {
+							touched.add(binding);
+
+							for (const assignment of binding.assignments) {
+								touch(assignment.value, assignment.scope, touched, seen);
 							}
 						}
 					}
 				}
-			);
-		};
+			}
+		);
+	};
+
+	/**
+	 * @param {ESTree.Node} node
+	 * @param {Set<ESTree.Node>} seen
+	 * @param {Set<Binding>} reads
+	 * @param {Set<Binding>} writes
+	 */
+	const trace_references = (node, reads, writes, seen = new Set()) => {
+		if (seen.has(node)) return;
+		seen.add(node);
 
 		/**
-		 * @param {ESTree.Node} node
-		 * @param {Set<ESTree.Node>} seen
-		 * @param {Set<Binding>} reads
-		 * @param {Set<Binding>} writes
+		 * @param {ESTree.Pattern} node
+		 * @param {Scope} scope
 		 */
-		const trace_references = (node, reads, writes, seen = new Set()) => {
-			if (seen.has(node)) return;
-			seen.add(node);
-
-			/**
-			 * @param {ESTree.Pattern} node
-			 * @param {Scope} scope
-			 */
-			function update(node, scope) {
-				for (const pattern of unwrap_pattern(node)) {
-					const node = object(pattern);
-					if (!node) return;
-
-					const binding = scope.get(node.name);
-					if (!binding) return;
-
-					writes.add(binding);
-				}
+		function update(node, scope) {
+			for (const pattern of unwrap_pattern(node)) {
+				const node = object(pattern);
+				if (!node) return;
+
+				const binding = scope.get(node.name);
+				if (!binding) return;
+
+				writes.add(binding);
 			}
+		}
 
-			walk(
-				node,
-				{ scope: instance.scope },
-				{
-					_(node, context) {
-						const scope = scopes.get(node);
-						if (scope) {
-							context.next({ scope });
-						} else {
-							context.next();
-						}
-					},
-					AssignmentExpression(node, context) {
-						update(node.left, context.state.scope);
-					},
-					UpdateExpression(node, context) {
-						update(
-							/** @type {ESTree.Identifier | ESTree.MemberExpression} */ (node.argument),
-							context.state.scope
-						);
-					},
-					CallExpression(node, context) {
-						// for now, assume everything touched by the callee ends up mutating the object
-						// TODO optimise this better
-
-						// special case — no need to peek inside effects
-						const rune = get_rune(node, context.state.scope);
-						if (rune === '$effect') return;
-
-						/** @type {Set<Binding>} */
-						const touched = new Set();
-						touch(node, context.state.scope, touched);
-
-						for (const b of touched) {
-							writes.add(b);
-						}
-					},
-					// don't look inside functions until they are called
-					ArrowFunctionExpression(_, context) {},
-					FunctionDeclaration(_, context) {},
-					FunctionExpression(_, context) {},
-					Identifier(node, context) {
-						const parent = /** @type {ESTree.Node} */ (context.path.at(-1));
-						if (is_reference(node, parent)) {
-							const binding = context.state.scope.get(node.name);
-							if (binding) {
-								reads.add(binding);
-							}
+		walk(
+			node,
+			{ scope: instance.scope },
+			{
+				_(node, context) {
+					const scope = scopes.get(node);
+					if (scope) {
+						context.next({ scope });
+					} else {
+						context.next();
+					}
+				},
+				AssignmentExpression(node, context) {
+					update(node.left, context.state.scope);
+				},
+				UpdateExpression(node, context) {
+					update(
+						/** @type {ESTree.Identifier | ESTree.MemberExpression} */ (node.argument),
+						context.state.scope
+					);
+				},
+				CallExpression(node, context) {
+					// for now, assume everything touched by the callee ends up mutating the object
+					// TODO optimise this better
+
+					// special case — no need to peek inside effects
+					const rune = get_rune(node, context.state.scope);
+					if (rune === '$effect') return;
+
+					/** @type {Set<Binding>} */
+					const touched = new Set();
+					touch(node, context.state.scope, touched);
+
+					for (const b of touched) {
+						writes.add(b);
+					}
+				},
+				// don't look inside functions until they are called
+				ArrowFunctionExpression(_, context) {},
+				FunctionDeclaration(_, context) {},
+				FunctionExpression(_, context) {},
+				Identifier(node, context) {
+					const parent = /** @type {ESTree.Node} */ (context.path.at(-1));
+					if (is_reference(node, parent)) {
+						const binding = context.state.scope.get(node.name);
+						if (binding) {
+							reads.add(binding);
 						}
 					}
 				}
-			);
-		};
+			}
+		);
+	};
 
-		let awaited = false;
+	let awaited = false;
 
-		// TODO this should probably be attached to the scope?
-		var promises = b.id('$$promises');
+	// TODO this should probably be attached to the scope?
+	var promises = b.id('$$promises');
 
-		/**
-		 * @param {ESTree.Identifier} id
-		 * @param {ESTree.Expression} blocker
-		 */
-		function push_declaration(id, blocker) {
-			analysis.instance_body.declarations.push(id);
+	/**
+	 * @param {ESTree.Identifier} id
+	 * @param {ESTree.Expression} blocker
+	 */
+	function push_declaration(id, blocker) {
+		analysis.instance_body.declarations.push(id);
+
+		const binding = /** @type {Binding} */ (instance.scope.get(id.name));
+		binding.blocker = blocker;
+	}
 
-			const binding = /** @type {Binding} */ (instance.scope.get(id.name));
-			binding.blocker = blocker;
+	for (let node of instance.ast.body) {
+		if (node.type === 'ImportDeclaration') {
+			analysis.instance_body.hoisted.push(node);
+			continue;
 		}
 
-		for (let node of instance.ast.body) {
-			if (node.type === 'ImportDeclaration') {
-				analysis.instance_body.hoisted.push(node);
-				continue;
-			}
+		if (node.type === 'ExportDefaultDeclaration' || node.type === 'ExportAllDeclaration') {
+			// these can't exist inside `<script>` but TypeScript doesn't know that
+			continue;
+		}
 
-			if (node.type === 'ExportDefaultDeclaration' || node.type === 'ExportAllDeclaration') {
-				// these can't exist inside `<script>` but TypeScript doesn't know that
+		if (node.type === 'ExportNamedDeclaration') {
+			if (node.declaration) {
+				node = node.declaration;
+			} else {
 				continue;
 			}
+		}
 
-			if (node.type === 'ExportNamedDeclaration') {
-				if (node.declaration) {
-					node = node.declaration;
-				} else {
-					continue;
-				}
-			}
-
-			const has_await = has_await_expression(node);
-			awaited ||= has_await;
+		const has_await = has_await_expression(node);
+		awaited ||= has_await;
 
-			if (awaited && node.type !== 'FunctionDeclaration') {
-				/** @type {Set<Binding>} */
-				const reads = new Set(); // TODO we're not actually using this yet
+		if (awaited && node.type !== 'FunctionDeclaration') {
+			/** @type {Set<Binding>} */
+			const reads = new Set(); // TODO we're not actually using this yet
 
-				/** @type {Set<Binding>} */
-				const writes = new Set();
+			/** @type {Set<Binding>} */
+			const writes = new Set();
 
-				trace_references(node, reads, writes);
+			trace_references(node, reads, writes);
 
-				const blocker = b.member(promises, b.literal(analysis.instance_body.async.length), true);
+			const blocker = b.member(promises, b.literal(analysis.instance_body.async.length), true);
 
-				for (const binding of writes) {
-					binding.blocker = blocker;
-				}
-
-				if (node.type === 'VariableDeclaration') {
-					for (const declarator of node.declarations) {
-						for (const id of extract_identifiers(declarator.id)) {
-							push_declaration(id, blocker);
-						}
+			for (const binding of writes) {
+				binding.blocker = blocker;
+			}
 
-						// one declarator per declaration, makes things simpler
-						analysis.instance_body.async.push({
-							node: declarator,
-							has_await
-						});
+			if (node.type === 'VariableDeclaration') {
+				for (const declarator of node.declarations) {
+					for (const id of extract_identifiers(declarator.id)) {
+						push_declaration(id, blocker);
 					}
-				} else if (node.type === 'ClassDeclaration') {
-					push_declaration(node.id, blocker);
-					analysis.instance_body.async.push({ node, has_await });
-				} else {
-					analysis.instance_body.async.push({ node, has_await });
+
+					// one declarator per declaration, makes things simpler
+					analysis.instance_body.async.push({
+						node: declarator,
+						has_await
+					});
 				}
+			} else if (node.type === 'ClassDeclaration') {
+				push_declaration(node.id, blocker);
+				analysis.instance_body.async.push({ node, has_await });
 			} else {
-				analysis.instance_body.sync.push(node);
+				analysis.instance_body.async.push({ node, has_await });
 			}
+		} else {
+			analysis.instance_body.sync.push(node);
+		}
+	}
+
+	if (analysis.runes) {
+		const props_refs = module.scope.references.get('$$props');
+		if (props_refs) {
+			e.legacy_props_invalid(props_refs[0].node);
+		}
+
+		const rest_props_refs = module.scope.references.get('$$restProps');
+		if (rest_props_refs) {
+			e.legacy_rest_props_invalid(rest_props_refs[0].node);
 		}
 
 		for (const { ast, scope, scopes } of [module, instance, template]) {
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
index 258298dc80..f51042eb7c 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
@@ -33,7 +33,6 @@ import { FunctionExpression } from './visitors/FunctionExpression.js';
 import { HtmlTag } from './visitors/HtmlTag.js';
 import { Identifier } from './visitors/Identifier.js';
 import { IfBlock } from './visitors/IfBlock.js';
-import { ImportDeclaration } from './visitors/ImportDeclaration.js';
 import { KeyBlock } from './visitors/KeyBlock.js';
 import { LabeledStatement } from './visitors/LabeledStatement.js';
 import { LetDirective } from './visitors/LetDirective.js';
@@ -111,7 +110,6 @@ const visitors = {
 	HtmlTag,
 	Identifier,
 	IfBlock,
-	ImportDeclaration,
 	KeyBlock,
 	LabeledStatement,
 	LetDirective,
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/ImportDeclaration.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/ImportDeclaration.js
deleted file mode 100644
index 20e3d9df49..0000000000
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/ImportDeclaration.js
+++ /dev/null
@@ -1,17 +0,0 @@
-/** @import { ImportDeclaration } from 'estree' */
-/** @import { ComponentContext } from '../types' */
-import * as b from '#compiler/builders';
-
-/**
- * @param {ImportDeclaration} node
- * @param {ComponentContext} context
- */
-export function ImportDeclaration(node, context) {
-	if ('hoisted' in context.state) {
-		// TODO we can get rid of this visitor
-		context.state.hoisted.push(node);
-		return b.empty;
-	}
-
-	context.next();
-}
diff --git a/packages/svelte/src/compiler/phases/3-transform/client/visitors/Program.js b/packages/svelte/src/compiler/phases/3-transform/client/visitors/Program.js
index 9702531d1d..f6352e986c 100644
--- a/packages/svelte/src/compiler/phases/3-transform/client/visitors/Program.js
+++ b/packages/svelte/src/compiler/phases/3-transform/client/visitors/Program.js
@@ -3,7 +3,6 @@
 import { build_getter, is_prop_source } from '../utils.js';
 import * as b from '#compiler/builders';
 import { add_state_transformers } from './shared/declarations.js';
-import { runes } from '../../../../state.js';
 import { transform_body } from '../../shared/transform-async.js';
 
 /**
@@ -139,15 +138,13 @@ export function Program(node, context) {
 
 	add_state_transformers(context);
 
-	if (context.state.is_instance && runes) {
+	if (context.state.is_instance) {
 		return {
 			...node,
 			body: transform_body(
-				node,
 				context.state.analysis.instance_body,
 				b.id('$.run'),
-				(node) => /** @type {Node} */ (context.visit(node)),
-				(statement) => context.state.hoisted.push(statement)
+				(node) => /** @type {Node} */ (context.visit(node))
 			)
 		};
 	}
diff --git a/packages/svelte/src/compiler/phases/3-transform/server/visitors/Program.js b/packages/svelte/src/compiler/phases/3-transform/server/visitors/Program.js
index 1bbe18b4d2..b40491db41 100644
--- a/packages/svelte/src/compiler/phases/3-transform/server/visitors/Program.js
+++ b/packages/svelte/src/compiler/phases/3-transform/server/visitors/Program.js
@@ -1,7 +1,6 @@
 /** @import { Node, Program } from 'estree' */
 /** @import { Context, ComponentContext } from '../types' */
 import * as b from '#compiler/builders';
-import { runes } from '../../../../state.js';
 import { transform_body } from '../../shared/transform-async.js';
 
 /**
@@ -9,18 +8,16 @@ import { transform_body } from '../../shared/transform-async.js';
  * @param {Context} context
  */
 export function Program(node, context) {
-	if (context.state.is_instance && runes) {
+	if (context.state.is_instance) {
 		// @ts-ignore wtf
 		const c = /** @type {ComponentContext} */ (context);
 
 		return {
 			...node,
 			body: transform_body(
-				node,
 				c.state.analysis.instance_body,
 				b.id('$$renderer.run'),
-				(node) => /** @type {Node} */ (context.visit(node)),
-				(statement) => c.state.hoisted.push(statement)
+				(node) => /** @type {Node} */ (context.visit(node))
 			)
 		};
 	}
diff --git a/packages/svelte/src/compiler/phases/3-transform/shared/transform-async.js b/packages/svelte/src/compiler/phases/3-transform/shared/transform-async.js
index 6cc7cd2a34..817c3ef1eb 100644
--- a/packages/svelte/src/compiler/phases/3-transform/shared/transform-async.js
+++ b/packages/svelte/src/compiler/phases/3-transform/shared/transform-async.js
@@ -2,15 +2,16 @@
 /** @import { ComponentAnalysis } from '../../types' */
 import * as b from '#compiler/builders';
 
-// TODO find a way to DRY out this and the corresponding server visitor
 /**
- * @param {ESTree.Program} program
  * @param {ComponentAnalysis['instance_body']} instance_body
  * @param {ESTree.Expression} runner
  * @param {(node: ESTree.Node) => ESTree.Node} transform
+ * @returns {Array<ESTree.Statement | ESTree.VariableDeclaration>}
  */
-export function transform_body(program, instance_body, runner, transform) {
-	const statements = instance_body.sync.map(transform);
+export function transform_body(instance_body, runner, transform) {
+	const statements = instance_body.sync.map(
+		(node) => /** @type {ESTree.Statement | ESTree.VariableDeclaration} */ (transform(node))
+	);
 
 	if (instance_body.declarations.length > 0) {
 		statements.push(