eslint-cdk-plugin 3.4.2 → 3.4.4

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import tsParser from '@typescript-eslint/parser';
 import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
+import { SymbolFlags, SyntaxKind, isClassDeclaration, isIdentifier, isPropertyAccessExpression, isConstructorDeclaration } from 'typescript';
 import * as path from 'path';
 
 var name = "eslint-cdk-plugin";
-var version = "3.4.2";
+var version = "3.4.4";
 
 const createRule = ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -120,21 +121,11 @@ const validateConstructorProperty = (constructor, context, parserServices) => {
   }
 };
 
-const SYMBOL_FLAGS = {
-  CLASS: 32};
-const SYNTAX_KIND = {
-  CLASS_DECLARATION: 263,
-  CONSTRUCTOR: 176,
-  IMPLEMENTS_KEYWORD: 119,
-  IDENTIFIER: 80,
-  PROPERTY_ACCESS_EXPRESSION: 211
-};
-
 const getSymbol = (type) => {
   return type.getSymbol?.() ?? type.symbol;
 };
 const isClassType = (type) => {
-  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
+  return getSymbol(type)?.flags === SymbolFlags.Class;
 };
 const isArrayType = (type) => {
   const symbol = getSymbol(type);
@@ -170,20 +161,8 @@ const getGenericTypeArgument = (type) => {
   return void 0;
 };
 
-const isClassDeclaration = (node) => {
-  return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
-};
-const isIdentifier = (node) => {
-  return node.kind === SYNTAX_KIND.IDENTIFIER;
-};
-const isPropertyAccessExpression = (node) => {
-  return node.kind === SYNTAX_KIND.PROPERTY_ACCESS_EXPRESSION;
-};
 const checkHeritageClauseIsImplements = (node) => {
-  return node.token === SYNTAX_KIND.IMPLEMENTS_KEYWORD;
-};
-const isConstructorDeclaration = (node) => {
-  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
+  return node.token === SyntaxKind.ImplementsKeyword;
 };
 
 const isResourceWithReadonlyInterface = (type) => {
@@ -948,76 +927,272 @@ const validateConstructId$2 = ({
   }
 };
 
-const propsUsageTrackerFactory = (propsType) => {
-  const getPropsPropertyNames = (propsType2) => {
-    const typeProperties = propsType2.getProperties();
-    if (typeProperties.length) {
-      return typeProperties.reduce(
-        (acc, prop) => !isInternalProperty(prop.name) ? [...acc, prop.name] : acc,
-        []
-      );
+const getChildNodes = (node) => {
+  return Object.entries(node).reduce((acc, [key, value]) => {
+    if (["parent", "range", "loc"].includes(key)) return acc;
+    if (isESTreeNode(value)) return [...acc, value];
+    if (Array.isArray(value)) return [...acc, ...value.filter(isESTreeNode)];
+    return acc;
+  }, []);
+};
+const isESTreeNode = (value) => {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+};
+
+class PropsUsageAnalyzer {
+  propsUsageTracker;
+  visitedNodes;
+  propsAliases;
+  constructor(propsUsageTracker) {
+    this.propsUsageTracker = propsUsageTracker;
+    this.visitedNodes = /* @__PURE__ */ new Set();
+    this.propsAliases = /* @__PURE__ */ new Set();
+  }
+  analyze(constructor, propsParam) {
+    this.initialize();
+    const constructorBody = constructor.value.body;
+    const classNode = constructor.parent;
+    const propsParamName = propsParam.name;
+    if (!constructorBody) return;
+    this.visitNodes(constructorBody, propsParamName);
+    this.analyzeClassBody(classNode, constructor, propsParamName);
+    this.analyzePrivateMethodsCalledFromConstructor(
+      constructorBody,
+      classNode,
+      propsParamName
+    );
+  }
+  initialize() {
+    this.visitedNodes.clear();
+    this.propsAliases.clear();
+  }
+  analyzeClassBody(classBody, constructor, propsParamName) {
+    if (!constructor.value.body) return;
+    const instanceVarName = this.findPropsInstanceVariable(
+      constructor.value.body,
+      propsParamName
+    );
+    if (!instanceVarName) return;
+    for (const member of classBody.body) {
+      if (member.type === AST_NODE_TYPES.MethodDefinition && member.value.body) {
+        this.visitNodes(member.value.body, instanceVarName);
+      }
     }
-    const symbol = propsType2.getSymbol();
-    if (!symbol?.members) return [];
-    return Array.from(symbol.members.keys()).reduce((acc, key) => {
-      const name = String(key);
-      return !isInternalProperty(name) ? [...acc, name] : acc;
-    }, []);
-  };
-  const isInternalProperty = (propertyName) => {
-    return propertyName.startsWith("_") || propertyName === "constructor" || propertyName === "prototype";
-  };
-  const markAsUsed = (propertyName) => {
-    if (propUsages.has(propertyName)) propUsages.set(propertyName, true);
-  };
-  const propUsages = new Map(
-    getPropsPropertyNames(propsType).map((name) => [name, false])
-  );
-  const getUnusedProperties = () => {
-    return Array.from(propUsages.entries()).reduce(
+  }
+  analyzePrivateMethodsCalledFromConstructor(constructorBody, classBody, propsParamName) {
+    const methodCallsWithProps = this.findMethodCallsWithProps(
+      constructorBody,
+      propsParamName
+    );
+    for (const { methodName, propsArgIndices } of methodCallsWithProps) {
+      const methodDef = this.findMethodDefinition(classBody, methodName);
+      if (!methodDef?.value.body) continue;
+      for (const argIndex of propsArgIndices) {
+        const param = methodDef.value.params[argIndex];
+        if (param && param.type === AST_NODE_TYPES.Identifier) {
+          this.visitNodes(methodDef.value.body, param.name);
+        }
+      }
+    }
+  }
+  visitNodes(node, propsParamName) {
+    if (this.visitedNodes.has(node)) return;
+    this.visitedNodes.add(node);
+    switch (node.type) {
+      case AST_NODE_TYPES.MemberExpression:
+        this.propsUsageTracker.markAsUsedForMemberExpression(
+          node,
+          propsParamName
+        );
+        if (node.object.type === AST_NODE_TYPES.Identifier && this.propsAliases.has(node.object.name) && node.property.type === AST_NODE_TYPES.Identifier) {
+          this.propsUsageTracker.markAsUsed(node.property.name);
+        }
+        break;
+      case AST_NODE_TYPES.VariableDeclarator:
+        this.propsUsageTracker.markAsUsedForVariableDeclarator(
+          node,
+          propsParamName
+        );
+        break;
+      case AST_NODE_TYPES.AssignmentExpression:
+        this.propsUsageTracker.markAsUsedForAssignmentExpression(
+          node,
+          propsParamName
+        );
+        break;
+      case AST_NODE_TYPES.Identifier:
+        if (node.name === propsParamName) this.handlePropsIdentifier(node);
+        break;
+    }
+    const children = getChildNodes(node);
+    for (const child of children) {
+      this.visitNodes(child, propsParamName);
+    }
+  }
+  /**
+   * Handles cases where props is used as a whole identifier
+   */
+  handlePropsIdentifier(node) {
+    const parent = node.parent;
+    if (!parent) return;
+    switch (parent.type) {
+      case AST_NODE_TYPES.AssignmentExpression:
+      case AST_NODE_TYPES.MemberExpression: {
+        break;
+      }
+      case AST_NODE_TYPES.VariableDeclarator: {
+        if (parent.init === node && parent.id.type === AST_NODE_TYPES.Identifier) {
+          this.propsAliases.add(parent.id.name);
+        }
+        break;
+      }
+      case AST_NODE_TYPES.CallExpression: {
+        if (!parent.arguments.includes(node)) break;
+        if (parent.callee.type === AST_NODE_TYPES.MemberExpression && parent.callee.object.type === AST_NODE_TYPES.ThisExpression) {
+          break;
+        }
+        this.propsUsageTracker.markAllAsUsed();
+        break;
+      }
+      case AST_NODE_TYPES.ReturnStatement: {
+        if (parent.argument === node) {
+          this.propsUsageTracker.markAllAsUsed();
+        }
+        break;
+      }
+      case AST_NODE_TYPES.ArrayExpression: {
+        if (parent.elements.includes(node)) {
+          this.propsUsageTracker.markAllAsUsed();
+        }
+        break;
+      }
+      case AST_NODE_TYPES.Property: {
+        if (parent.value === node) {
+          this.propsUsageTracker.markAllAsUsed();
+        }
+        break;
+      }
+    }
+  }
+  findPropsInstanceVariable(body, propsParamName) {
+    for (const statement of body.body) {
+      if (statement.type === AST_NODE_TYPES.ExpressionStatement && statement.expression.type === AST_NODE_TYPES.AssignmentExpression && statement.expression.left.type === AST_NODE_TYPES.MemberExpression && statement.expression.left.object.type === AST_NODE_TYPES.ThisExpression && statement.expression.left.property.type === AST_NODE_TYPES.Identifier && statement.expression.right.type === AST_NODE_TYPES.Identifier && statement.expression.right.name === propsParamName) {
+        return statement.expression.left.property.name;
+      }
+    }
+    return null;
+  }
+  /**
+   * Finds method definition in class body
+   */
+  findMethodDefinition(classBody, methodName) {
+    for (const member of classBody.body) {
+      if (member.type === AST_NODE_TYPES.MethodDefinition && member.key.type === AST_NODE_TYPES.Identifier && member.key.name === methodName) {
+        return member;
+      }
+    }
+    return null;
+  }
+  /**
+   * Finds method calls in constructor body that receive props as argument
+   */
+  findMethodCallsWithProps(body, propsParamName) {
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visitNode = (node) => {
+      if (visited.has(node)) return;
+      visited.add(node);
+      if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.ThisExpression && node.callee.property.type === AST_NODE_TYPES.Identifier) {
+        const methodName = node.callee.property.name;
+        const propsArgIndices = node.arguments.reduce(
+          (acc, arg, index) => arg.type === AST_NODE_TYPES.Identifier && arg.name === propsParamName ? (
+            // NOTE: props is passed directly (e.g., this.method(props))
+            [...acc, index]
+          ) : acc,
+          []
+        );
+        if (propsArgIndices.length) {
+          result.push({ methodName, propsArgIndices });
+        }
+      }
+      const children = getChildNodes(node);
+      for (const child of children) {
+        visitNode(child);
+      }
+    };
+    visitNode(body);
+    return result;
+  }
+}
+
+class PropsUsageTracker {
+  propUsageMap;
+  constructor(propType) {
+    this.propUsageMap = new Map(
+      this.getPropsPropertyNames(propType).map((name) => [name, false])
+    );
+  }
+  getUnusedProperties() {
+    return Array.from(this.propUsageMap.entries()).reduce(
       (acc, [name, used]) => !used ? [...acc, name] : acc,
       []
     );
-  };
-  const markAsUsedForMemberExpression = (node, propsParamName) => {
+  }
+  markAsUsed(propertyName) {
+    if (this.propUsageMap.has(propertyName)) {
+      this.propUsageMap.set(propertyName, true);
+    }
+  }
+  markAllAsUsed() {
+    for (const key of this.propUsageMap.keys()) {
+      this.propUsageMap.set(key, true);
+    }
+  }
+  markAsUsedForMemberExpression(node, propsParamName) {
     if (node.object.type === AST_NODE_TYPES.Identifier && node.object.name === propsParamName && node.property.type === AST_NODE_TYPES.Identifier) {
-      markAsUsed(node.property.name);
+      this.markAsUsed(node.property.name);
       return;
     }
-    if (node.object.type === AST_NODE_TYPES.MemberExpression && node.object.object.type === AST_NODE_TYPES.ThisExpression && node.object.property.type === AST_NODE_TYPES.Identifier && node.object.property.name === "props" && node.property.type === AST_NODE_TYPES.Identifier) {
-      markAsUsed(node.property.name);
+    if (node.object.type === AST_NODE_TYPES.MemberExpression && node.object.object.type === AST_NODE_TYPES.ThisExpression && node.object.property.type === AST_NODE_TYPES.Identifier && node.object.property.name === propsParamName && node.property.type === AST_NODE_TYPES.Identifier) {
+      this.markAsUsed(node.property.name);
       return;
     }
-  };
-  const markAsUsedForVariableDeclarator = (node, propsParamName) => {
+  }
+  markAsUsedForVariableDeclarator(node, propsParamName) {
     if (node.id.type !== AST_NODE_TYPES.ObjectPattern || node.init?.type !== AST_NODE_TYPES.Identifier || node.init.name !== propsParamName) {
       return;
     }
     const propertyNames = getPropertyNames(node.id.properties);
     for (const name of propertyNames) {
-      markAsUsed(name);
+      this.markAsUsed(name);
     }
-  };
-  const markAsUsedForAssignmentExpression = (node, propsParamName) => {
+  }
+  markAsUsedForAssignmentExpression(node, propsParamName) {
     if (node.right.type !== AST_NODE_TYPES.MemberExpression || node.right.object.type !== AST_NODE_TYPES.Identifier || node.right.object.name !== propsParamName || node.right.property.type !== AST_NODE_TYPES.Identifier) {
       return;
     }
-    markAsUsed(node.right.property.name);
-  };
-  const markAsUsedForObjectPattern = (node) => {
-    for (const propName of getPropertyNames(node.properties)) {
-      markAsUsed(propName);
+    this.markAsUsed(node.right.property.name);
+  }
+  /**
+   * Gets the property names from the props type
+   */
+  getPropsPropertyNames(propsType) {
+    const isInternalProperty = (propertyName) => propertyName.startsWith("_") || propertyName === "constructor" || propertyName === "prototype";
+    const typeProperties = propsType.getProperties();
+    if (typeProperties.length) {
+      return typeProperties.reduce(
+        (acc, prop) => !isInternalProperty(prop.name) ? [...acc, prop.name] : acc,
+        []
+      );
     }
-  };
-  if (!propUsages.size) return null;
-  return {
-    getUnusedProperties,
-    markAsUsedForMemberExpression,
-    markAsUsedForVariableDeclarator,
-    markAsUsedForAssignmentExpression,
-    markAsUsedForObjectPattern
-  };
-};
+    const symbol = propsType.getSymbol();
+    if (!symbol?.members) return [];
+    return Array.from(symbol.members.keys()).reduce((acc, key) => {
+      const name = String(key);
+      return !isInternalProperty(name) ? [...acc, name] : acc;
+    }, []);
+  }
+}
 
 const noUnusedProps = createRule({
   name: "no-unused-props",
@@ -1036,64 +1211,61 @@ const noUnusedProps = createRule({
     const parserServices = ESLintUtils.getParserServices(context);
     return {
       ClassDeclaration(node) {
+        if (node.abstract) return;
         const type = parserServices.getTypeAtLocation(node);
         if (!isConstructType(type)) return;
         const constructor = getConstructor(node);
         if (!constructor) return;
-        analyzePropsUsage(constructor, context, parserServices);
+        const propsParam = getPropsParam(constructor, parserServices);
+        if (!propsParam) return;
+        const { node: propsNode, type: propsType } = propsParam;
+        if (isPropsUsedInSuperCall(constructor, propsNode.name)) return;
+        const tracker = new PropsUsageTracker(propsType);
+        const analyzer = new PropsUsageAnalyzer(tracker);
+        analyzer.analyze(constructor, propsNode);
+        reportUnusedProperties(tracker, propsNode, context);
       }
     };
   }
 });
-const analyzePropsUsage = (constructor, context, parserServices) => {
+const getPropsParam = (constructor, parserServices) => {
   const params = constructor.value.params;
-  if (params.length < 3) return;
+  if (params.length < 3) return null;
   const propsParam = params[2];
-  switch (propsParam.type) {
-    case AST_NODE_TYPES.Identifier: {
-      const propsType = parserServices.getTypeAtLocation(propsParam);
-      const tracker = propsUsageTrackerFactory(propsType);
-      if (!tracker || !constructor.value.body) return;
-      analyzeConstructorBody(constructor.value.body, propsParam.name, tracker);
-      reportUnusedProperties(tracker, propsParam, context);
-      return;
-    }
-    case AST_NODE_TYPES.ObjectPattern: {
-      const typeAnnotation = propsParam.typeAnnotation?.typeAnnotation;
-      if (!typeAnnotation) return;
-      const propsType = parserServices.getTypeAtLocation(typeAnnotation);
-      const tracker = propsUsageTrackerFactory(propsType);
-      if (!tracker) return;
-      tracker.markAsUsedForObjectPattern(propsParam);
-      reportUnusedProperties(tracker, propsParam, context);
-      return;
-    }
-    default:
-      return;
-  }
+  if (propsParam.type !== AST_NODE_TYPES.Identifier) return null;
+  return {
+    node: propsParam,
+    type: parserServices.getTypeAtLocation(propsParam)
+  };
 };
-const analyzeConstructorBody = (body, propsParamName, tracker) => {
-  const visited = /* @__PURE__ */ new Set();
-  const visitNode = (node) => {
-    if (visited.has(node)) return;
-    visited.add(node);
-    switch (node.type) {
-      case AST_NODE_TYPES.MemberExpression:
-        tracker.markAsUsedForMemberExpression(node, propsParamName);
-        break;
-      case AST_NODE_TYPES.VariableDeclarator:
-        tracker.markAsUsedForVariableDeclarator(node, propsParamName);
-        break;
-      case AST_NODE_TYPES.AssignmentExpression:
-        tracker.markAsUsedForAssignmentExpression(node, propsParamName);
-        break;
+const isPropsUsedInSuperCall = (constructor, propsPropertyName) => {
+  if (constructor.kind !== "constructor") return false;
+  const body = constructor.value.body;
+  if (!body) return false;
+  for (const expr of body.body) {
+    if (expr.type !== AST_NODE_TYPES.ExpressionStatement || expr.expression.type !== AST_NODE_TYPES.CallExpression || expr.expression.callee.type !== AST_NODE_TYPES.Super) {
+      continue;
     }
-    const children = getChildNodes(node);
-    for (const child of children) {
-      visitNode(child);
+    const visitNode = (node, propsName) => {
+      const nodeValue = node.type === AST_NODE_TYPES.Property ? node.value : node;
+      switch (nodeValue.type) {
+        case AST_NODE_TYPES.Identifier: {
+          return nodeValue.name === propsName;
+        }
+        case AST_NODE_TYPES.ObjectExpression: {
+          for (const prop of nodeValue.properties) {
+            if (visitNode(prop, propsName)) return true;
+          }
+          break;
+        }
+      }
+      return false;
+    };
+    for (const arg of expr.expression.arguments) {
+      if (visitNode(arg, propsPropertyName)) return true;
     }
-  };
-  visitNode(body);
+  }
+  return false;
 };
 const reportUnusedProperties = (tracker, propsParam, context) => {
   for (const propName of tracker.getUnusedProperties()) {
@@ -1106,17 +1278,6 @@ const reportUnusedProperties = (tracker, propsParam, context) => {
     });
   }
 };
-const getChildNodes = (node) => {
-  return Object.entries(node).reduce((acc, [key, value]) => {
-    if (["parent", "range", "loc"].includes(key)) return acc;
-    if (isESTreeNode(value)) return [...acc, value];
-    if (Array.isArray(value)) return [...acc, ...value.filter(isESTreeNode)];
-    return acc;
-  }, []);
-};
-const isESTreeNode = (value) => {
-  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
-};
 
 const noVariableConstructId = createRule({
   name: "no-variable-construct-id",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "3.4.2",
+  "version": "3.4.4",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -30,25 +30,28 @@
     "prebuild": "rolldown -c"
   },
   "devDependencies": {
-    "@eslint/js": "^9.26.0",
+    "@eslint/js": "^9.36.0",
     "@secretlint/secretlint-rule-preset-recommend": "^11.2.4",
-    "@types/node": "^22.15.0",
-    "@typescript-eslint/rule-tester": "^8.32.1",
+    "@types/node": "^24.9.2",
+    "@typescript-eslint/rule-tester": "^8.46.2",
     "@vitest/coverage-v8": "3.2.4",
     "commander": "^14.0.1",
     "consola": "^3.4.2",
-    "eslint": "9.36.0",
+    "eslint": "^9.38.0",
     "eslint-plugin-import": "^2.32.0",
-    "pkgroll": "^2.12.2",
+    "pkgroll": "^2.20.1",
     "rolldown": "1.0.0-beta.45",
     "secretlint": "^11.2.4",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.32.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2",
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@typescript-eslint/parser": "^8.32.1",
-    "@typescript-eslint/utils": "^8.32.1"
+    "@typescript-eslint/parser": "^8.46.2",
+    "@typescript-eslint/utils": "^8.46.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
   },
   "engines": {
     "node": "^18.18.0 || ^20.9.0 || >=21.1.0"