@fuzdev/fuz_util 0.49.0 → 0.49.2

package/dist/svelte_preprocess_helpers.d.ts

@@ -41,14 +41,16 @@ export declare const find_attribute: (node: AST.Component, name: string) => AST.
 /**
  * Recursively evaluates an expression AST node to a static string value.
  *
- * Handles string `Literal`, `TemplateLiteral` without interpolation, and
- * `BinaryExpression` with the `+` operator (string concatenation).
+ * Handles string `Literal`, `TemplateLiteral` (including interpolations when all
+ * expressions resolve), `BinaryExpression` with `+`, and `Identifier` lookup
+ * via an optional bindings map built by `build_static_bindings`.
  * Returns `null` for dynamic expressions, non-string literals, or unsupported node types.
  *
  * @param expr An ESTree expression AST node.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the expression is dynamic.
  */
-export declare const evaluate_static_expr: (expr: Expression) => string | null;
+export declare const evaluate_static_expr: (expr: Expression, bindings?: ReadonlyMap<string, string>) => string | null;
 /**
  * Extracts a static string value from a Svelte attribute value AST node.
  *
@@ -61,9 +63,25 @@ export declare const evaluate_static_expr: (expr: Expression) => string | null;
  * Returns `null` for null literals, mixed arrays, dynamic expressions, and non-string values.
  *
  * @param value The attribute value from `AST.Attribute['value']`.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the value is dynamic.
  */
-export declare const extract_static_string: (value: AST.Attribute["value"]) => string | null;
+export declare const extract_static_string: (value: AST.Attribute["value"], bindings?: ReadonlyMap<string, string>) => string | null;
+/**
+ * Builds a map of statically resolvable `const` bindings from a Svelte AST.
+ *
+ * Scans top-level `const` variable declarations in both instance and module scripts.
+ * For each declarator with a plain `Identifier` pattern and a statically evaluable
+ * initializer, adds the binding to the map. Processes declarations in source order
+ * so that chained references resolve: `const a = 'x'; const b = a;` maps `b` to `'x'`.
+ *
+ * Skips destructuring patterns, `let`/`var` declarations, and declarations
+ * whose initializers reference dynamic values.
+ *
+ * @param ast The parsed Svelte AST root node.
+ * @returns Map of variable names to their resolved static string values.
+ */
+export declare const build_static_bindings: (ast: AST.Root) => Map<string, string>;
 /**
  * Resolves local names that import from specified source paths.
  *
@@ -105,6 +123,10 @@ export declare const generate_import_lines: (imports: Map<string, PreprocessImpo
  * `skip` set are excluded from traversal — used to skip `ImportDeclaration`
  * nodes so the import's own specifier identifier doesn't false-positive.
  *
+ * Skips `Identifier` nodes in non-reference positions defined by
+ * `NON_REFERENCE_FIELDS` — for example, `obj.Mdz` (non-computed member property),
+ * `{ Mdz: value }` (non-computed object key), and statement labels.
+ *
  * Safe for Svelte template ASTs: `Component.name` is a plain string property
  * (not an `Identifier` node), so `<Mdz>` tags do not produce false matches.
  *

package/dist/svelte_preprocess_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte_preprocess_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte_preprocess_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,eAAe,EAAC,MAAM,QAAQ,CAAC;AACnG,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAEzC,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACpC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;CAC1B;AAED,qDAAqD;AACrD,MAAM,WAAW,uBAAuB;IACvC,gEAAgE;IAChE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,mDAAmD;IACnD,SAAS,EAAE,eAAe,GAAG,sBAAsB,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG,CAAC,SAAS,EAAE,MAAM,MAAM,KAAG,GAAG,CAAC,SAAS,GAAG,SAOlF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,IAchE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,KAAG,MAAM,GAAG,IAkB9E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GACnC,KAAK,GAAG,CAAC,IAAI,EACb,mBAAmB,KAAK,CAAC,MAAM,CAAC,KAC9B,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAcrC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ,GAAG,CAAC,MAAM,KAAG,MAYhE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,SAAS,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC1C,SAAQ,MAAa,KACnB,MAyBF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,MAAM,MAAM,EACZ,OAAO,GAAG,CAAC,OAAO,CAAC,KACjB,OAYF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAc/C,CAAC"}
+{"version":3,"file":"svelte_preprocess_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte_preprocess_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,eAAe,EAAC,MAAM,QAAQ,CAAC;AACnG,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAEzC,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACpC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;CAC1B;AAED,qDAAqD;AACrD,MAAM,WAAW,uBAAuB;IACvC,gEAAgE;IAChE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,mDAAmD;IACnD,SAAS,EAAE,eAAe,GAAG,sBAAsB,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,GAAG,CAAC,SAAS,EAAE,MAAM,MAAM,KAAG,GAAG,CAAC,SAAS,GAAG,SAOlF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAChC,MAAM,UAAU,EAChB,WAAW,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KACpC,MAAM,GAAG,IA+BX,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,GACjC,OAAO,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,EAC7B,WAAW,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KACpC,MAAM,GAAG,IAkBX,CAAC;AAOF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,GAAG,CAAC,IAAI,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAiBvE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GACnC,KAAK,GAAG,CAAC,IAAI,EACb,mBAAmB,KAAK,CAAC,MAAM,CAAC,KAC9B,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAcrC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ,GAAG,CAAC,MAAM,KAAG,MAYhE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,SAAS,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC1C,SAAQ,MAAa,KACnB,MAyBF,CAAC;AA0BF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,MAAM,MAAM,EACZ,OAAO,GAAG,CAAC,OAAO,CAAC,KACjB,OAgBF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAc/C,CAAC"}

package/dist/svelte_preprocess_helpers.js

@@ -32,30 +32,50 @@ export const find_attribute = (node, name) => {
 /**
  * Recursively evaluates an expression AST node to a static string value.
  *
- * Handles string `Literal`, `TemplateLiteral` without interpolation, and
- * `BinaryExpression` with the `+` operator (string concatenation).
+ * Handles string `Literal`, `TemplateLiteral` (including interpolations when all
+ * expressions resolve), `BinaryExpression` with `+`, and `Identifier` lookup
+ * via an optional bindings map built by `build_static_bindings`.
  * Returns `null` for dynamic expressions, non-string literals, or unsupported node types.
  *
  * @param expr An ESTree expression AST node.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the expression is dynamic.
  */
-export const evaluate_static_expr = (expr) => {
+export const evaluate_static_expr = (expr, bindings) => {
     if (expr.type === 'Literal' && typeof expr.value === 'string')
         return expr.value;
-    if (expr.type === 'TemplateLiteral' && expr.expressions.length === 0) {
-        return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+    if (expr.type === 'TemplateLiteral') {
+        if (expr.expressions.length === 0) {
+            return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+        }
+        // Try resolving interpolations through bindings
+        const parts = [];
+        for (let i = 0; i < expr.quasis.length; i++) {
+            const quasi = expr.quasis[i];
+            parts.push(quasi.value.cooked ?? quasi.value.raw);
+            if (i < expr.expressions.length) {
+                const val = evaluate_static_expr(expr.expressions[i], bindings);
+                if (val === null)
+                    return null;
+                parts.push(val);
+            }
+        }
+        return parts.join('');
     }
     if (expr.type === 'BinaryExpression' && expr.operator === '+') {
         if (expr.left.type === 'PrivateIdentifier')
             return null;
-        const left = evaluate_static_expr(expr.left);
+        const left = evaluate_static_expr(expr.left, bindings);
         if (left === null)
             return null;
-        const right = evaluate_static_expr(expr.right);
+        const right = evaluate_static_expr(expr.right, bindings);
         if (right === null)
             return null;
         return left + right;
     }
+    if (expr.type === 'Identifier' && bindings?.has(expr.name)) {
+        return bindings.get(expr.name);
+    }
     return null;
 };
 /**
@@ -70,9 +90,10 @@ export const evaluate_static_expr = (expr) => {
  * Returns `null` for null literals, mixed arrays, dynamic expressions, and non-string values.
  *
  * @param value The attribute value from `AST.Attribute['value']`.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the value is dynamic.
  */
-export const extract_static_string = (value) => {
+export const extract_static_string = (value, bindings) => {
     // Boolean attribute (e.g., <Mdz inline />)
     if (value === true)
         return null;
@@ -89,7 +110,47 @@ export const extract_static_string = (value) => {
     // Null literal
     if (expr.type === 'Literal' && expr.value === null)
         return null;
-    return evaluate_static_expr(expr);
+    return evaluate_static_expr(expr, bindings);
+};
+// TODO cross-import tracing: resolve `import {x} from './constants.js'` by reading
+// and parsing the imported module, extracting `export const` values. Would need path
+// resolution ($lib, tsconfig paths), a Program-node variant of this function, and
+// cache invalidation when the imported file changes. Start with relative .ts/.js only.
+/**
+ * Builds a map of statically resolvable `const` bindings from a Svelte AST.
+ *
+ * Scans top-level `const` variable declarations in both instance and module scripts.
+ * For each declarator with a plain `Identifier` pattern and a statically evaluable
+ * initializer, adds the binding to the map. Processes declarations in source order
+ * so that chained references resolve: `const a = 'x'; const b = a;` maps `b` to `'x'`.
+ *
+ * Skips destructuring patterns, `let`/`var` declarations, and declarations
+ * whose initializers reference dynamic values.
+ *
+ * @param ast The parsed Svelte AST root node.
+ * @returns Map of variable names to their resolved static string values.
+ */
+export const build_static_bindings = (ast) => {
+    const bindings = new Map();
+    for (const script of [ast.instance, ast.module]) {
+        if (!script)
+            continue;
+        for (const node of script.content.body) {
+            if (node.type !== 'VariableDeclaration' || node.kind !== 'const')
+                continue;
+            for (const declarator of node.declarations) {
+                if (declarator.id.type !== 'Identifier')
+                    continue;
+                if (!declarator.init)
+                    continue;
+                const value = evaluate_static_expr(declarator.init, bindings);
+                if (value !== null) {
+                    bindings.set(declarator.id.name, value);
+                }
+            }
+        }
+    }
+    return bindings;
 };
 /**
  * Resolves local names that import from specified source paths.
@@ -178,6 +239,26 @@ export const generate_import_lines = (imports, indent = '\t') => {
     }
     return lines.join('\n');
 };
+/**
+ * ESTree node fields that contain `Identifier` nodes which are NOT binding references.
+ *
+ * Keyed by node type. Each entry lists fields to skip during identifier search,
+ * optionally conditioned on the node's `computed` property being falsy.
+ *
+ * Examples of non-reference positions:
+ * - `obj.Mdz` — `MemberExpression.property` when `computed: false`
+ * - `{ Mdz: value }` — `Property.key` when `computed: false`
+ * - `label: for(...)` — `LabeledStatement.label`
+ */
+const NON_REFERENCE_FIELDS = new Map([
+    ['MemberExpression', [{ field: 'property', when_not_computed: true }]],
+    ['Property', [{ field: 'key', when_not_computed: true }]],
+    ['PropertyDefinition', [{ field: 'key', when_not_computed: true }]],
+    ['MethodDefinition', [{ field: 'key', when_not_computed: true }]],
+    ['LabeledStatement', [{ field: 'label' }]],
+    ['BreakStatement', [{ field: 'label' }]],
+    ['ContinueStatement', [{ field: 'label' }]],
+]);
 /**
  * Checks if an identifier with the given name appears anywhere in an AST subtree.
  *
@@ -186,6 +267,10 @@ export const generate_import_lines = (imports, indent = '\t') => {
  * `skip` set are excluded from traversal — used to skip `ImportDeclaration`
  * nodes so the import's own specifier identifier doesn't false-positive.
  *
+ * Skips `Identifier` nodes in non-reference positions defined by
+ * `NON_REFERENCE_FIELDS` — for example, `obj.Mdz` (non-computed member property),
+ * `{ Mdz: value }` (non-computed object key), and statement labels.
+ *
  * Safe for Svelte template ASTs: `Component.name` is a plain string property
  * (not an `Identifier` node), so `<Mdz>` tags do not produce false matches.
  *
@@ -205,7 +290,11 @@ export const has_identifier_in_tree = (node, name, skip) => {
     const record = node;
     if (record.type === 'Identifier' && record.name === name)
         return true;
+    const rules = NON_REFERENCE_FIELDS.get(record.type);
     for (const key of Object.keys(record)) {
+        if (rules?.some((r) => r.field === key && (!r.when_not_computed || !record.computed))) {
+            continue;
+        }
         if (has_identifier_in_tree(record[key], name, skip))
             return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_util",
-  "version": "0.49.0",
+  "version": "0.49.2",
   "description": "utility belt for JS",
   "glyph": "🦕",
   "logo": "logo.svg",

package/src/lib/svelte_preprocess_helpers.ts

@@ -53,26 +53,48 @@ export const find_attribute = (node: AST.Component, name: string): AST.Attribute
 /**
  * Recursively evaluates an expression AST node to a static string value.
  *
- * Handles string `Literal`, `TemplateLiteral` without interpolation, and
- * `BinaryExpression` with the `+` operator (string concatenation).
+ * Handles string `Literal`, `TemplateLiteral` (including interpolations when all
+ * expressions resolve), `BinaryExpression` with `+`, and `Identifier` lookup
+ * via an optional bindings map built by `build_static_bindings`.
  * Returns `null` for dynamic expressions, non-string literals, or unsupported node types.
  *
  * @param expr An ESTree expression AST node.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the expression is dynamic.
  */
-export const evaluate_static_expr = (expr: Expression): string | null => {
+export const evaluate_static_expr = (
+	expr: Expression,
+	bindings?: ReadonlyMap<string, string>,
+): string | null => {
 	if (expr.type === 'Literal' && typeof expr.value === 'string') return expr.value;
-	if (expr.type === 'TemplateLiteral' && expr.expressions.length === 0) {
-		return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+	if (expr.type === 'TemplateLiteral') {
+		if (expr.expressions.length === 0) {
+			return expr.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+		}
+		// Try resolving interpolations through bindings
+		const parts: Array<string> = [];
+		for (let i = 0; i < expr.quasis.length; i++) {
+			const quasi = expr.quasis[i]!;
+			parts.push(quasi.value.cooked ?? quasi.value.raw);
+			if (i < expr.expressions.length) {
+				const val = evaluate_static_expr(expr.expressions[i]!, bindings);
+				if (val === null) return null;
+				parts.push(val);
+			}
+		}
+		return parts.join('');
 	}
 	if (expr.type === 'BinaryExpression' && expr.operator === '+') {
 		if (expr.left.type === 'PrivateIdentifier') return null;
-		const left = evaluate_static_expr(expr.left);
+		const left = evaluate_static_expr(expr.left, bindings);
 		if (left === null) return null;
-		const right = evaluate_static_expr(expr.right);
+		const right = evaluate_static_expr(expr.right, bindings);
 		if (right === null) return null;
 		return left + right;
 	}
+	if (expr.type === 'Identifier' && bindings?.has(expr.name)) {
+		return bindings.get(expr.name)!;
+	}
 	return null;
 };
 
@@ -88,9 +110,13 @@ export const evaluate_static_expr = (expr: Expression): string | null => {
  * Returns `null` for null literals, mixed arrays, dynamic expressions, and non-string values.
  *
  * @param value The attribute value from `AST.Attribute['value']`.
+ * @param bindings Optional map of variable names to their resolved static string values.
  * @returns The resolved static string, or `null` if the value is dynamic.
  */
-export const extract_static_string = (value: AST.Attribute['value']): string | null => {
+export const extract_static_string = (
+	value: AST.Attribute['value'],
+	bindings?: ReadonlyMap<string, string>,
+): string | null => {
 	// Boolean attribute (e.g., <Mdz inline />)
 	if (value === true) return null;
 
@@ -107,7 +133,45 @@ export const extract_static_string = (value: AST.Attribute['value']): string | n
 	const expr = value.expression;
 	// Null literal
 	if (expr.type === 'Literal' && expr.value === null) return null;
-	return evaluate_static_expr(expr);
+	return evaluate_static_expr(expr, bindings);
+};
+
+// TODO cross-import tracing: resolve `import {x} from './constants.js'` by reading
+// and parsing the imported module, extracting `export const` values. Would need path
+// resolution ($lib, tsconfig paths), a Program-node variant of this function, and
+// cache invalidation when the imported file changes. Start with relative .ts/.js only.
+
+/**
+ * Builds a map of statically resolvable `const` bindings from a Svelte AST.
+ *
+ * Scans top-level `const` variable declarations in both instance and module scripts.
+ * For each declarator with a plain `Identifier` pattern and a statically evaluable
+ * initializer, adds the binding to the map. Processes declarations in source order
+ * so that chained references resolve: `const a = 'x'; const b = a;` maps `b` to `'x'`.
+ *
+ * Skips destructuring patterns, `let`/`var` declarations, and declarations
+ * whose initializers reference dynamic values.
+ *
+ * @param ast The parsed Svelte AST root node.
+ * @returns Map of variable names to their resolved static string values.
+ */
+export const build_static_bindings = (ast: AST.Root): Map<string, string> => {
+	const bindings: Map<string, string> = new Map();
+	for (const script of [ast.instance, ast.module]) {
+		if (!script) continue;
+		for (const node of script.content.body) {
+			if (node.type !== 'VariableDeclaration' || node.kind !== 'const') continue;
+			for (const declarator of node.declarations) {
+				if (declarator.id.type !== 'Identifier') continue;
+				if (!declarator.init) continue;
+				const value = evaluate_static_expr(declarator.init, bindings);
+				if (value !== null) {
+					bindings.set(declarator.id.name, value);
+				}
+			}
+		}
+	}
+	return bindings;
 };
 
 /**
@@ -203,6 +267,30 @@ export const generate_import_lines = (
 	return lines.join('\n');
 };
 
+/**
+ * ESTree node fields that contain `Identifier` nodes which are NOT binding references.
+ *
+ * Keyed by node type. Each entry lists fields to skip during identifier search,
+ * optionally conditioned on the node's `computed` property being falsy.
+ *
+ * Examples of non-reference positions:
+ * - `obj.Mdz` — `MemberExpression.property` when `computed: false`
+ * - `{ Mdz: value }` — `Property.key` when `computed: false`
+ * - `label: for(...)` — `LabeledStatement.label`
+ */
+const NON_REFERENCE_FIELDS: Map<
+	string,
+	Array<{field: string; when_not_computed?: boolean}>
+> = new Map([
+	['MemberExpression', [{field: 'property', when_not_computed: true}]],
+	['Property', [{field: 'key', when_not_computed: true}]],
+	['PropertyDefinition', [{field: 'key', when_not_computed: true}]],
+	['MethodDefinition', [{field: 'key', when_not_computed: true}]],
+	['LabeledStatement', [{field: 'label'}]],
+	['BreakStatement', [{field: 'label'}]],
+	['ContinueStatement', [{field: 'label'}]],
+]);
+
 /**
  * Checks if an identifier with the given name appears anywhere in an AST subtree.
  *
@@ -211,6 +299,10 @@ export const generate_import_lines = (
  * `skip` set are excluded from traversal — used to skip `ImportDeclaration`
  * nodes so the import's own specifier identifier doesn't false-positive.
  *
+ * Skips `Identifier` nodes in non-reference positions defined by
+ * `NON_REFERENCE_FIELDS` — for example, `obj.Mdz` (non-computed member property),
+ * `{ Mdz: value }` (non-computed object key), and statement labels.
+ *
  * Safe for Svelte template ASTs: `Component.name` is a plain string property
  * (not an `Identifier` node), so `<Mdz>` tags do not produce false matches.
  *
@@ -231,7 +323,11 @@ export const has_identifier_in_tree = (
 	}
 	const record = node as Record<string, unknown>;
 	if (record.type === 'Identifier' && record.name === name) return true;
+	const rules = NON_REFERENCE_FIELDS.get(record.type as string);
 	for (const key of Object.keys(record)) {
+		if (rules?.some((r) => r.field === key && (!r.when_not_computed || !record.computed))) {
+			continue;
+		}
 		if (has_identifier_in_tree(record[key], name, skip)) return true;
 	}
 	return false;