chore: refactor is_inlinable_expression to accept the attribute

Author: paoloricciuti

packages/svelte/src/compiler/phases/2-analyze/visitors/ExpressionTag.js

@@ -22,7 +22,7 @@ export function ExpressionTag(node, context) {
 	 * the subtree as dynamic. This is because if it's inlinable it will be inlined in the template
 	 * directly making the whole thing actually static.
 	 */
-	if (!attribute_parent || !is_inlinable_expression(node, context.state.scope)) {
+	if (!attribute_parent || !is_inlinable_expression(attribute_parent, context.state.scope)) {
 		// TODO ideally we wouldn't do this here, we'd just do it on encountering
 		// an `Identifier` within the tag. But we currently need to handle `{42}` etc
 		mark_subtree_dynamic(context.path);

packages/svelte/src/compiler/phases/2-analyze/visitors/Identifier.js

@@ -21,19 +21,14 @@ export function Identifier(node, context) {
 		return;
 	}
 
-	const expression_tag_parent = context.path.find((parent) => parent.type === 'ExpressionTag');
 	const attribute_parent = context.path.find((parent) => parent.type === 'Attribute');
 
 	/**
 	 * if the identifier is part of an expression tag of an attribute we want to check if it's inlinable
 	 * before marking the subtree as dynamic. This is because if it's inlinable it will be inlined in the template
 	 * directly making the whole thing actually static.
 	 */
-	if (
-		!attribute_parent ||
-		!expression_tag_parent ||
-		!is_inlinable_expression(expression_tag_parent, context.state.scope)
-	) {
+	if (!attribute_parent || !is_inlinable_expression(attribute_parent, context.state.scope)) {
 		mark_subtree_dynamic(context.path);
 	}
 

packages/svelte/src/compiler/phases/3-transform/client/visitors/RegularElement.js

@@ -578,10 +578,7 @@ function build_element_attribute_update_assignment(element, node_id, attribute,
 		);
 	}
 
-	const inlinable_expression =
-		attribute.value === true
-			? false // not an expression
-			: is_inlinable_expression(attribute.value, context.state.scope);
+	const inlinable_expression = is_inlinable_expression(attribute, context.state.scope);
 	if (attribute.metadata.expression.has_state) {
 		if (has_call) {
 			state.init.push(build_update(update));

packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/fragment.js

@@ -159,7 +159,7 @@ function is_static_element(node, state) {
 			!is_text_attribute(attribute) &&
 			// If the attribute is not a text attribute but is inlinable we will directly inline it in the
 			// the template so before returning false we need to check that the attribute is not inlinable
-			!is_inlinable_expression(attribute.value, state.scope)
+			!is_inlinable_expression(attribute, state.scope)
 		) {
 			return false;
 		}

packages/svelte/src/compiler/phases/utils.js

@@ -1,4 +1,5 @@
 /** @import { AST, Binding } from '#compiler' */
+/** @import { Scope } from './scope' */
 
 /**
  * Whether a variable can be referenced directly from template string.
@@ -16,11 +17,12 @@ function can_inline_variable(binding) {
 }
 
 /**
- * @param {(AST.Text | AST.ExpressionTag) | (AST.Text | AST.ExpressionTag)[]} node_or_nodes
- * @param {import('./scope.js').Scope} scope
+ * @param {AST.Attribute} attribute
+ * @param {Scope} scope
  */
-export function is_inlinable_expression(node_or_nodes, scope) {
-	let nodes = Array.isArray(node_or_nodes) ? node_or_nodes : [node_or_nodes];
+export function is_inlinable_expression(attribute, scope) {
+	if (attribute.value === true) return false; // not an expression
+	let nodes = Array.isArray(attribute.value) ? attribute.value : [attribute.value];
 	let has_expression_tag = false;
 	for (let value of nodes) {
 		if (value.type === 'ExpressionTag') {