All files / src/compiler/phases/2-analyze/visitors Identifier.js

97.4% Statements 150/154
95.31% Branches 61/64
100% Functions 1/1
97.31% Lines 145/149

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 1502x 2x 2x 2x 2x 2x 2x 2x 2x 2x 2x 2x 2x 44618x 44618x 44618x 44618x 9335x 9335x 35283x 35283x 35283x 44618x 3x 44618x 1x 1x 35282x 35282x 44618x 12x 12x 35282x 44618x 10452x 10452x 10452x 1669x 10452x 1624x 1624x 1624x 1624x 1624x 116x 116x 116x 116x 116x 116x 116x 2x 1x 1x 1x 2x     1x 1x 1x 116x 1622x 1624x 2x 2x 1624x 10452x 35278x 35278x 35278x 39051x 24830x 68x 68x 24830x 24830x 57x 57x 24830x 24830x 24830x 14083x 14083x 14083x 24830x 9225x 9225x 9225x 2813x 2813x 9225x 687x 9225x 8538x 8538x 20x 8538x     24830x 217x 217x 217x 1330x 1330x 1330x 237x 237x 1330x 217x 197x 24x 24x 197x 217x 217x 1330x 217x 24830x 35278x 44618x 32401x 10181x 10181x 10181x 32401x 32401x 32401x 32401x 32401x 605x 605x 605x 58x 39x 39x 39x 605x 605x 32401x 34x 32401x 21x 32401x 16x 16x 32401x 44618x  
/** @import { Expression, Identifier } from 'estree' */
/** @import { Context } from '../types' */
import is_reference from 'is-reference';
import { should_proxy } from '../../3-transform/client/utils.js';
import * as e from '../../../errors.js';
import * as w from '../../../warnings.js';
import { is_rune } from '../../../../utils.js';
 
/**
 * @param {Identifier} node
 * @param {Context} context
 */
export function Identifier(node, context) {
	let i = context.path.length;
	let parent = /** @type {Expression} */ (context.path[--i]);
 
	if (!is_reference(node, parent)) {
		return;
	}
 
	// If we are using arguments outside of a function, then throw an error
	if (
		node.name === 'arguments' &&
		!context.path.some((n) => n.type === 'FunctionDeclaration' || n.type === 'FunctionExpression')
	) {
		e.invalid_arguments_usage(node);
	}
 
	// `$$slots` exists even in runes mode
	if (node.name === '$$slots') {
		context.state.analysis.uses_slots = true;
	}
 
	if (context.state.analysis.runes) {
		if (
			is_rune(node.name) &&
			context.state.scope.get(node.name) === null &&
			context.state.scope.get(node.name.slice(1)) === null
		) {
			/** @type {Expression} */
			let current = node;
			let name = node.name;
 
			while (parent.type === 'MemberExpression') {
				if (parent.computed) e.rune_invalid_computed_property(parent);
				name += `.${/** @type {Identifier} */ (parent.property).name}`;
 
				current = parent;
				parent = /** @type {Expression} */ (context.path[--i]);
 
				if (!is_rune(name)) {
					if (name === '$effect.active') {
						e.rune_renamed(parent, '$effect.active', '$effect.tracking');
					}
 
					if (name === '$state.frozen') {
						e.rune_renamed(parent, '$state.frozen', '$state.raw');
					}
 
					e.rune_invalid_name(parent, name);
				}
			}
 
			if (parent.type !== 'CallExpression') {
				e.rune_missing_parentheses(current);
			}
		}
	}
 
	let binding = context.state.scope.get(node.name);
 
	if (!context.state.analysis.runes) {
		if (node.name === '$$props') {
			context.state.analysis.uses_props = true;
		}
 
		if (node.name === '$$restProps') {
			context.state.analysis.uses_rest_props = true;
		}
 
		if (
			binding?.kind === 'normal' &&
			((binding.scope === context.state.instance_scope &&
				binding.declaration_kind !== 'function') ||
				binding.declaration_kind === 'import')
		) {
			if (
				binding.declaration_kind !== 'import' &&
				binding.mutated &&
				// TODO could be more fine-grained - not every mention in the template implies a state binding
				(context.state.reactive_statement || context.state.ast_type === 'template')
			) {
				binding.kind = 'state';
			} else if (
				context.state.reactive_statement &&
				parent.type === 'AssignmentExpression' &&
				parent.left === binding.node
			) {
				binding.kind = 'derived';
			}
		} else if (binding?.kind === 'each' && binding.mutated) {
			// Ensure that the array is marked as reactive even when only its entries are mutated
			let i = context.path.length;
			while (i--) {
				const ancestor = context.path[i];
				if (
					ancestor.type === 'EachBlock' &&
					context.state.analysis.template.scopes.get(ancestor)?.declarations.get(node.name) ===
						binding
				) {
					for (const binding of ancestor.metadata.references) {
						if (binding.kind === 'normal') {
							binding.kind = 'state';
						}
					}
					break;
				}
			}
		}
	}
 
	if (binding) {
		if (context.state.expression) {
			context.state.expression.dependencies.add(binding);
			context.state.expression.has_state ||= binding.kind !== 'normal';
		}
 
		if (
			context.state.analysis.runes &&
			node !== binding.node &&
			context.state.function_depth === binding.scope.function_depth &&
			// If we have $state that can be proxied or frozen and isn't re-assigned, then that means
			// it's likely not using a primitive value and thus this warning isn't that helpful.
			((binding.kind === 'state' &&
				(binding.reassigned ||
					(binding.initial?.type === 'CallExpression' &&
						binding.initial.arguments.length === 1 &&
						binding.initial.arguments[0].type !== 'SpreadElement' &&
						!should_proxy(binding.initial.arguments[0], context.state.scope)))) ||
				binding.kind === 'raw_state' ||
				binding.kind === 'derived') &&
			// We're only concerned with reads here
			(parent.type !== 'AssignmentExpression' || parent.left !== node) &&
			parent.type !== 'UpdateExpression'
		) {
			w.state_referenced_locally(node);
		}
	}
}