@eslint-react/var 3.0.0-next.62 → 3.0.0-next.64

package/dist/index.d.ts

@@ -1,38 +1,8 @@
-import { unit } from "@eslint-react/eff";
+import { Scope } from "@typescript-eslint/scope-manager";
 import { TSESTree } from "@typescript-eslint/types";
-import { Scope, Variable } from "@typescript-eslint/scope-manager";
 import { RuleContext } from "@eslint-react/shared";
 
-//#region src/find-enclosing-assignment-target.d.ts
-/**
- * Finds the enclosing assignment target (variable, property, etc.) for a given node
- *
- * @todo Verify correctness and completeness of this function
- * @param node The starting node
- * @returns The enclosing assignment target node, or undefined if not found
- */
-declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | undefined;
-/**
- * Type representing the possible assignment targets returned by `findEnclosingAssignmentTarget`
- */
-type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
-//#endregion
-//#region src/find-variable.d.ts
-/**
- * Find a variable by name or identifier node in the scope chain
- * @param initialScope The scope to start searching from
- * @returns The found variable or unit if not found
- * @overload
- * @param nameOrNode The variable name or identifier node to find
- * @param initialScope The scope to start searching from
- * @returns The found variable or unit if not found
- */
-declare const findVariable: {
-  (initialScope: Scope): (nameOrNode: string | TSESTree.Identifier | unit) => Variable | unit;
-  (nameOrNode: string | TSESTree.Identifier | unit, initialScope: Scope): Variable | unit;
-};
-//#endregion
-//#region src/get-object-type.d.ts
+//#region src/compute-object-type.d.ts
 /**
  * Represents the type classification of an object node
  */
@@ -65,10 +35,23 @@ type ObjectType = {
 /**
  * Detect the ObjectType of a given node
  * @param node The node to check
- * @param initialScope  The initial scope to check for variable declarations
  * @returns The ObjectType of the node, or undefined if not detected
  */
-declare function getObjectType(node: TSESTree.Node | unit, initialScope: Scope): ObjectType | unit;
+declare function computeObjectType(context: RuleContext, node: TSESTree.Node | null): ObjectType | null;
+//#endregion
+//#region src/find-enclosing-assignment-target.d.ts
+/**
+ * Finds the enclosing assignment target (variable, property, etc.) for a given node
+ *
+ * @todo Verify correctness and completeness of this function
+ * @param node The starting node
+ * @returns The enclosing assignment target node, or null if not found
+ */
+declare function findEnclosingAssignmentTarget(node: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | null;
+/**
+ * Type representing the possible assignment targets returned by `findEnclosingAssignmentTarget`
+ */
+type AssignmentTarget = ReturnType<typeof findEnclosingAssignmentTarget>;
 //#endregion
 //#region src/is-assignment-target-equal.d.ts
 /**
@@ -92,4 +75,36 @@ declare function isAssignmentTargetEqual(context: RuleContext, a: TSESTree.Node,
  */
 declare function isValueEqual(a: TSESTree.Node, b: TSESTree.Node, initialScopes: [aScope: Scope, bScope: Scope]): boolean;
 //#endregion
-export { AssignmentTarget, ObjectType, findEnclosingAssignmentTarget, findVariable, getObjectType, isAssignmentTargetEqual, isValueEqual };
+//#region src/resolve.d.ts
+/**
+ * Resolves an identifier to the AST node that represents its value,
+ * suitable for use in ESLint rule analysis.
+ *
+ * The resolution follows these rules per definition type:
+ *
+ * | Definition type          | `def.node`                                   | Returns                            |
+ * |--------------------------|----------------------------------------------|------------------------------------|
+ * | `Variable`               | `VariableDeclarator`                         | `def.node.init` (or `null`)        |
+ * | `FunctionName`           | `FunctionDeclaration` / `FunctionExpression` | `def.node`                         |
+ * | `ClassName`              | `ClassDeclaration` / `ClassExpression`       | `def.node`                         |
+ * | `Parameter`              | containing function node                     | `def.node` (if a real function)    |
+ * | `TSEnumName`             | `TSEnumDeclaration`                          | `def.node`                         |
+ * | `TSEnumMember`           | `TSEnumMember`                               | `def.node.initializer` (or `null`) |
+ * | `ImportBinding`          | import specifier                             | `null`                             |
+ * | `CatchClause`            | `CatchClause`                                | `null`                             |
+ * | `TSModuleName`           | `TSModuleDeclaration`                        | `null`                             |
+ * | `Type`                   | type alias node                              | `null`                             |
+ * | `ImplicitGlobalVariable` | any node                                     | `null`                             |
+ *
+ * @param context The ESLint rule context used for scope lookup.
+ * @param node The identifier to resolve.
+ * @param at Which definition to use when multiple exist (default: `0`; pass `-1` for the last).
+ * @param localOnly When `true`, look up the variable only in the node's own scope (faster, but
+ *   will miss variables declared in an outer scope). When `false` (default), traverse the scope
+ *   chain upward via `findVariable` so that references to outer-scope bindings are resolved
+ *   correctly.
+ * @returns The resolved node, or `null` if the identifier cannot be resolved to a value node.
+ */
+declare function resolve(context: RuleContext, node: TSESTree.Identifier, at?: number, localOnly?: boolean): TSESTree.Node | null;
+//#endregion
+export { AssignmentTarget, ObjectType, computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, isValueEqual, resolve };

package/dist/index.js

@@ -1,54 +1,74 @@
-import { dual, unit } from "@eslint-react/eff";
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import * as astUtils from "@typescript-eslint/utils/ast-utils";
-import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { DefinitionType } from "@typescript-eslint/scope-manager";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import * as ast from "@eslint-react/ast";
+import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 
-//#region src/find-enclosing-assignment-target.ts
+//#region src/resolve.ts
 /**
-* Finds the enclosing assignment target (variable, property, etc.) for a given node
+* Resolves an identifier to the AST node that represents its value,
+* suitable for use in ESLint rule analysis.
 *
-* @todo Verify correctness and completeness of this function
-* @param node The starting node
-* @returns The enclosing assignment target node, or undefined if not found
+* The resolution follows these rules per definition type:
+*
+* | Definition type          | `def.node`                                   | Returns                            |
+* |--------------------------|----------------------------------------------|------------------------------------|
+* | `Variable`               | `VariableDeclarator`                         | `def.node.init` (or `null`)        |
+* | `FunctionName`           | `FunctionDeclaration` / `FunctionExpression` | `def.node`                         |
+* | `ClassName`              | `ClassDeclaration` / `ClassExpression`       | `def.node`                         |
+* | `Parameter`              | containing function node                     | `def.node` (if a real function)    |
+* | `TSEnumName`             | `TSEnumDeclaration`                          | `def.node`                         |
+* | `TSEnumMember`           | `TSEnumMember`                               | `def.node.initializer` (or `null`) |
+* | `ImportBinding`          | import specifier                             | `null`                             |
+* | `CatchClause`            | `CatchClause`                                | `null`                             |
+* | `TSModuleName`           | `TSModuleDeclaration`                        | `null`                             |
+* | `Type`                   | type alias node                              | `null`                             |
+* | `ImplicitGlobalVariable` | any node                                     | `null`                             |
+*
+* @param context The ESLint rule context used for scope lookup.
+* @param node The identifier to resolve.
+* @param at Which definition to use when multiple exist (default: `0`; pass `-1` for the last).
+* @param localOnly When `true`, look up the variable only in the node's own scope (faster, but
+*   will miss variables declared in an outer scope). When `false` (default), traverse the scope
+*   chain upward via `findVariable` so that references to outer-scope bindings are resolved
+*   correctly.
+* @returns The resolved node, or `null` if the identifier cannot be resolved to a value node.
 */
-function findEnclosingAssignmentTarget(node) {
-	switch (true) {
-		case node.type === AST_NODE_TYPES.VariableDeclarator: return node.id;
-		case node.type === AST_NODE_TYPES.AssignmentExpression: return node.left;
-		case node.type === AST_NODE_TYPES.PropertyDefinition: return node.key;
-		case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return unit;
-		default: return findEnclosingAssignmentTarget(node.parent);
+function resolve(context, node, at = 0, localOnly = false) {
+	const scope = context.sourceCode.getScope(node);
+	const variable = localOnly ? scope.set.get(node.name) : findVariable(scope, node);
+	if (variable == null) return null;
+	const def = variable.defs.at(at);
+	if (def == null) return null;
+	switch (def.type) {
+		case DefinitionType.FunctionName: return def.node;
+		case DefinitionType.ClassName: return def.node;
+		case DefinitionType.Variable: {
+			const { init } = def.node;
+			if (init == null) return null;
+			if ("declarations" in init) return null;
+			return init;
+		}
+		case DefinitionType.Parameter: return ast.isFunction(def.node) ? def.node : null;
+		case DefinitionType.TSEnumName: return def.node;
+		case DefinitionType.TSEnumMember: return def.node.initializer ?? null;
+		case DefinitionType.ImportBinding: return null;
+		case DefinitionType.CatchClause: return null;
+		case DefinitionType.TSModuleName: return null;
+		case DefinitionType.Type: return null;
+		case DefinitionType.ImplicitGlobalVariable: return null;
+		default: return null;
 	}
 }
 
 //#endregion
-//#region src/find-variable.ts
-/**
-* Find a variable by name or identifier node in the scope chain
-* @param initialScope The scope to start searching from
-* @returns The found variable or unit if not found
-* @overload
-* @param nameOrNode The variable name or identifier node to find
-* @param initialScope The scope to start searching from
-* @returns The found variable or unit if not found
-*/
-const findVariable = dual(2, (nameOrNode, initialScope) => {
-	if (nameOrNode == null) return unit;
-	return astUtils.findVariable(initialScope, nameOrNode) ?? unit;
-});
-
-//#endregion
-//#region src/get-object-type.ts
+//#region src/compute-object-type.ts
 /**
 * Detect the ObjectType of a given node
 * @param node The node to check
-* @param initialScope  The initial scope to check for variable declarations
 * @returns The ObjectType of the node, or undefined if not detected
 */
-function getObjectType(node, initialScope) {
-	if (node == null) return unit;
+function computeObjectType(context, node) {
+	if (node == null) return null;
 	switch (node.type) {
 		case AST_NODE_TYPES.JSXElement:
 		case AST_NODE_TYPES.JSXFragment: return {
@@ -83,42 +103,53 @@ function getObjectType(node, initialScope) {
 				kind: "regexp",
 				node
 			};
-			return unit;
+			return null;
 		case AST_NODE_TYPES.Identifier: {
-			const initNode = resolve(initialScope.set.get(node.name));
-			if (initNode == null) return unit;
-			return getObjectType(initNode, initialScope);
+			if ((context.sourceCode.getScope(node).set.get(node.name)?.defs.at(-1))?.type === DefinitionType.Parameter) return null;
+			const initNode = resolve(context, node, -1, true);
+			if (initNode == null) return null;
+			return computeObjectType(context, initNode);
 		}
 		case AST_NODE_TYPES.MemberExpression:
-			if (!("object" in node)) return unit;
-			return getObjectType(node.object, initialScope);
+			if (!("object" in node)) return null;
+			return computeObjectType(context, node.object);
 		case AST_NODE_TYPES.AssignmentExpression:
 		case AST_NODE_TYPES.AssignmentPattern:
-			if (!("right" in node)) return unit;
-			return getObjectType(node.right, initialScope);
-		case AST_NODE_TYPES.LogicalExpression: return getObjectType(node.right, initialScope);
-		case AST_NODE_TYPES.ConditionalExpression: return getObjectType(node.consequent, initialScope) ?? getObjectType(node.alternate, initialScope);
+			if (!("right" in node)) return null;
+			return computeObjectType(context, node.right);
+		case AST_NODE_TYPES.LogicalExpression: return computeObjectType(context, node.right);
+		case AST_NODE_TYPES.ConditionalExpression: return computeObjectType(context, node.consequent) ?? computeObjectType(context, node.alternate);
 		case AST_NODE_TYPES.SequenceExpression:
-			if (node.expressions.length === 0) return unit;
-			return getObjectType(node.expressions[node.expressions.length - 1], initialScope);
+			if (node.expressions.length === 0) return null;
+			return computeObjectType(context, node.expressions[node.expressions.length - 1] ?? null);
 		case AST_NODE_TYPES.CallExpression: return {
 			kind: "unknown",
 			node,
 			reason: "call-expression"
 		};
 		default:
-			if (!("expression" in node) || typeof node.expression !== "object") return unit;
-			return getObjectType(node.expression, initialScope);
+			if (!("expression" in node) || typeof node.expression !== "object") return null;
+			return computeObjectType(context, node.expression);
 	}
 }
-function resolve(v) {
-	if (v == null) return unit;
-	const def = v.defs.at(-1);
-	if (def == null) return unit;
-	if (def.type === DefinitionType.Variable) return def.node.init;
-	if (def.type === DefinitionType.Parameter) return unit;
-	if (def.type === DefinitionType.ImportBinding) return unit;
-	return def.node;
+
+//#endregion
+//#region src/find-enclosing-assignment-target.ts
+/**
+* Finds the enclosing assignment target (variable, property, etc.) for a given node
+*
+* @todo Verify correctness and completeness of this function
+* @param node The starting node
+* @returns The enclosing assignment target node, or null if not found
+*/
+function findEnclosingAssignmentTarget(node) {
+	switch (true) {
+		case node.type === AST_NODE_TYPES.VariableDeclarator: return node.id;
+		case node.type === AST_NODE_TYPES.AssignmentExpression: return node.left;
+		case node.type === AST_NODE_TYPES.PropertyDefinition: return node.key;
+		case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return null;
+		default: return findEnclosingAssignmentTarget(node.parent);
+	}
 }
 
 //#endregion
@@ -145,10 +176,10 @@ function isValueEqual(a, b, initialScopes) {
 		case a.type === AST_NODE_TYPES.Literal && b.type === AST_NODE_TYPES.Literal: return a.value === b.value;
 		case a.type === AST_NODE_TYPES.TemplateElement && b.type === AST_NODE_TYPES.TemplateElement: return a.value.cooked === b.value.cooked;
 		case a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier: {
-			const aVar = findVariable(a, aScope);
-			const bVar = findVariable(b, bScope);
+			const aVar = findVariable(aScope, a);
+			const bVar = findVariable(bScope, b);
 			const resolve = (variable) => {
-				if (variable == null) return unit;
+				if (variable == null) return null;
 				const def = variable.defs.at(0);
 				if (def != null) switch (true) {
 					case def.type === DefinitionType.FunctionName && def.node.type === AST_NODE_TYPES.FunctionDeclaration: return def.node;
@@ -156,7 +187,7 @@ function isValueEqual(a, b, initialScopes) {
 					case "init" in def.node && def.node.init != null && !("declarations" in def.node.init): return def.node.init;
 				}
 				if (def?.type === DefinitionType.Parameter && ast.isFunction(def.node)) return def.node;
-				return unit;
+				return null;
 			};
 			const aVarInit = resolve(aVar);
 			const bVarInit = resolve(bVar);
@@ -214,4 +245,4 @@ function isAssignmentTargetEqual(context, a, b) {
 }
 
 //#endregion
-export { findEnclosingAssignmentTarget, findVariable, getObjectType, isAssignmentTargetEqual, isValueEqual };
+export { computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, isValueEqual, resolve };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/var",
-  "version": "3.0.0-next.62",
+  "version": "3.0.0-next.64",
   "description": "ESLint React's TSESTree AST utility module for static analysis of variables.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,11 +34,12 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.62",
-    "@eslint-react/eff": "3.0.0-next.62",
-    "@eslint-react/shared": "3.0.0-next.62"
+    "@eslint-react/ast": "3.0.0-next.64",
+    "@eslint-react/eff": "3.0.0-next.64",
+    "@eslint-react/shared": "3.0.0-next.64"
   },
   "devDependencies": {
+    "@typescript-eslint/typescript-estree": "canary",
     "tsdown": "^0.21.0-beta.2",
     "@local/configs": "0.0.0"
   },