distinguish between identifiers (reassignments) and member expressions (mutations)

Author: Rich-Harris

packages/svelte/src/compiler/phases/3-transform/server/transform-server.js

@@ -2024,8 +2024,7 @@ export function server_component(analysis, options) {
 
 		if (
 			node.body.type === 'ExpressionStatement' &&
-			node.body.expression.type === 'AssignmentExpression' &&
-			node.body.expression.left.type !== 'MemberExpression'
+			node.body.expression.type === 'AssignmentExpression'
 		) {
 			for (const id of extract_identifiers(node.body.expression.left)) {
 				const binding = analysis.instance.scope.get(id.name);

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

@@ -3,7 +3,12 @@ import { walk } from 'zimmerframe';
 import { is_element_node } from './nodes.js';
 import * as b from '../utils/builders.js';
 import * as e from '../errors.js';
-import { extract_identifiers, extract_identifiers_from_destructuring } from '../utils/ast.js';
+import {
+	extract_identifiers,
+	extract_identifiers_from_destructuring,
+	object,
+	unwrap_pattern
+} from '../utils/ast.js';
 import { JsKeywords, Runes } from './constants.js';
 
 export class Scope {
@@ -361,8 +366,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
 
 			if (
 				node.body.type === 'ExpressionStatement' &&
-				node.body.expression.type === 'AssignmentExpression' &&
-				node.body.expression.left.type !== 'MemberExpression'
+				node.body.expression.type === 'AssignmentExpression'
 			) {
 				for (const id of extract_identifiers(node.body.expression.left)) {
 					if (!id.name.startsWith('$')) {
@@ -714,11 +718,14 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
 			const binding = scope.get(/** @type {import('estree').Identifier} */ (object).name);
 			if (binding) binding.mutated = true;
 		} else {
-			extract_identifiers(node, [], true).forEach((identifier) => {
-				const binding = scope.get(identifier.name);
-				if (binding && identifier !== binding.node) {
+			unwrap_pattern(node).forEach((node) => {
+				let id = node.type === 'Identifier' ? node : object(node);
+				if (id === null) return;
+
+				const binding = scope.get(id.name);
+				if (binding && id !== binding.node) {
 					binding.mutated = true;
-					binding.reassigned = true;
+					binding.reassigned = node.type === 'Identifier';
 				}
 			});
 		}

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

@@ -54,53 +54,60 @@ export function is_event_attribute(attribute) {
 }
 
 /**
- * Extracts all identifiers from a pattern.
- * @param {ESTree.Pattern} param
- * @param {ESTree.Identifier[]} [nodes]
- * @returns {ESTree.Identifier[]}
+ * Extracts all identifiers and member expressions from a pattern.
+ * @param {ESTree.Pattern} pattern
+ * @param {Array<ESTree.Identifier | ESTree.MemberExpression>} [nodes]
+ * @returns {Array<ESTree.Identifier | ESTree.MemberExpression>}
  */
-export function extract_identifiers(param, nodes = []) {
-	switch (param.type) {
+export function unwrap_pattern(pattern, nodes = []) {
+	switch (pattern.type) {
 		case 'Identifier':
-			nodes.push(param);
+			nodes.push(pattern);
 			break;
 
 		case 'MemberExpression':
-			// Only the `a` from `[a.b[c].d]` is of interest to us here
-			const id = object(param);
-			if (id) nodes.push(id);
+			nodes.push(pattern);
 			break;
 
 		case 'ObjectPattern':
-			for (const prop of param.properties) {
+			for (const prop of pattern.properties) {
 				if (prop.type === 'RestElement') {
-					extract_identifiers(prop.argument, nodes);
+					unwrap_pattern(prop.argument, nodes);
 				} else {
-					extract_identifiers(prop.value, nodes);
+					unwrap_pattern(prop.value, nodes);
 				}
 			}
 
 			break;
 
 		case 'ArrayPattern':
-			for (const element of param.elements) {
-				if (element) extract_identifiers(element, nodes);
+			for (const element of pattern.elements) {
+				if (element) unwrap_pattern(element, nodes);
 			}
 
 			break;
 
 		case 'RestElement':
-			extract_identifiers(param.argument, nodes);
+			unwrap_pattern(pattern.argument, nodes);
 			break;
 
 		case 'AssignmentPattern':
-			extract_identifiers(param.left, nodes);
+			unwrap_pattern(pattern.left, nodes);
 			break;
 	}
 
 	return nodes;
 }
 
+/**
+ * Extracts all identifiers from a pattern.
+ * @param {ESTree.Pattern} pattern
+ * @returns {ESTree.Identifier[]}
+ */
+export function extract_identifiers(pattern) {
+	return unwrap_pattern(pattern, []).filter((node) => node.type === 'Identifier');
+}
+
 /**
  * Extracts all identifiers and a stringified keypath from an expression.
  * @param {ESTree.Expression} expr