mm_eslint 1.4.3 → 1.4.5

package/handler.js

@@ -0,0 +1,993 @@
+const { Detector } = require('./detector');
+const { Fix } = require('./fix');
+
+/**
+ * 规则处理器类
+ * 负责处理特定AST节点类型的检测逻辑
+ */
+class Handler {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    this.config = config;
+    this.detector = new Detector(config);
+    this.fix = new Fix(config);
+  }
+
+
+
+  /**
+   * 处理类声明节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整的AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleClassDeclaration(context, full_node, node, rule_type) {
+    // 检测类名
+    if (node.id && node.id.type === 'Identifier') {
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, node.id.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createClassFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+
+    // 检测继承的父类名
+    if (node.superClass && node.superClass.type === 'Identifier') {
+      // 父类名应该使用PascalCase
+      var parent_class_result = this.detector.detect(node, node.superClass.name);
+      if (parent_class_result) {
+        parent_class_result.node = full_node;
+        parent_class_result.fix = this.fix.createClassFixFunction(context, full_node, parent_class_result);
+        context.report(parent_class_result);
+      }
+    }
+  }
+
+  /**
+   * 处理变量声明节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整的AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleVariableDeclaration(context, full_node, node, rule_type) {
+    for (var i = 0; i < node.declarations.length; i++) {
+      var decl = node.declarations[i];
+
+      // 跳过解构赋值
+      if (decl.init && decl.init.type === 'ObjectPattern') {
+        continue;
+      }
+
+      // 检测变量名
+      if (decl.id && decl.id.type === 'Identifier') {
+        // 先检测节点类型
+        var detected_type = this.detector.detectTypeOnly(node);
+
+        // 根据规则类型进行过滤
+        if (this._shouldSkipDetection(rule_type, detected_type)) {
+          continue;
+        }
+
+        // 使用detect方法，它会自动检测类型
+        var result = this.detector.detect(node, decl.id.name);
+        if (result) {
+          // 再次检查过滤条件，确保检测到的类型和规则匹配
+          if (this._shouldSkipDetection(rule_type, result.original_type)) {
+            continue;
+          }
+          result.node = full_node;
+          
+          // 根据检测到的类型选择正确的修复函数
+          if (result.original_type === 'class' && decl.init && decl.init.type === 'ClassExpression') {
+            // 对于类表达式，传递VariableDeclarator节点而不是ClassExpression节点
+            // 因为需要修复的是变量名，而不是类名
+            result.node = decl;
+            result.fix = this.fix.createVariableFixFunction(context, decl, result);
+          } else if (result.original_type.includes('class-instance')) {
+            // 对于类实例，传递VariableDeclarator节点而不是VariableDeclaration节点
+            result.node = decl;
+            result.fix = this.fix.createVariableFixFunction(context, decl, result);
+          } else if (result.original_type.includes('function')) {
+            // 对于函数类型，使用函数修复函数
+            // 对于箭头函数赋值，传递VariableDeclarator节点而不是VariableDeclaration节点
+            if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
+              result.node = decl;
+              result.fix = this.fix.createFunctionFixFunction(context, decl, result);
+            } else {
+              result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+            }
+          } else {
+            // 其他情况使用变量修复函数
+            result.fix = this.fix.createVariableFixFunction(context, full_node, result);
+          }
+          
+          context.report(result);
+        }
+      }
+
+      // 检测类表达式内部的类名（新增逻辑）
+      if (decl.init && decl.init.type === 'ClassExpression' && decl.init.id && decl.init.id.type === 'Identifier') {
+        // 先检测节点类型
+        var class_detected_type = this.detector.detectTypeOnly(decl.init);
+
+        // 根据规则类型进行过滤
+        if (this._shouldSkipDetection(rule_type, class_detected_type)) {
+          continue;
+        }
+
+        // 使用detect方法检测类表达式内部的类名
+        var class_result = this.detector.detect(decl.init, decl.init.id.name);
+        if (class_result) {
+          // 再次检查过滤条件，确保检测到的类型和规则匹配
+          if (this._shouldSkipDetection(rule_type, class_result.original_type)) {
+            continue;
+          }
+          class_result.node = decl.init;
+          class_result.fix = this.fix.createClassFixFunction(context, decl.init, class_result);
+          context.report(class_result);
+        }
+      }
+    }
+  }
+
+  /**
+   * 处理属性节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整的AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleProperty(context, full_node, node, rule_type) {
+    if (node.key && node.key.type === 'Identifier') {
+      // 跳过解构赋值中的属性
+      if (this._isDestructuringProperty(node)) {
+        return;
+      }
+
+      // 跳过函数参数引用
+      if (this._isParameterReference(node)) {
+        return;
+      }
+
+      // 跳过module.exports中的属性
+      if (this._isModuleExportsProperty(node)) {
+        return;
+      }
+
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      // 使用detect方法，它会自动检测类型
+      var result = this.detector.detect(node, node.key.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createPropertyFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理赋值表达式节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整的AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleAssignmentExpression(context, full_node, node, rule_type) {
+    // 处理数组中的赋值表达式（如 [User = new UserClass()]）
+    if (node.parent && node.parent.type === 'ArrayExpression' &&
+      node.left && node.left.type === 'Identifier') {
+
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+      var result = this.detector.detect(node, node.left.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createVariableFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+
+    // 处理 exports.XXX = ... 形式的导出
+    if (node.left &&
+      node.left.type === 'MemberExpression' &&
+      node.left.object &&
+      node.left.object.type === 'Identifier' &&
+      node.left.object.name === 'exports' &&
+      node.left.property &&
+      node.left.property.type === 'Identifier') {
+
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, node.left.property.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createPropertyFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+
+    // 处理原型方法（如 Usersb.prototype._GetUserpe = function() {}）
+    if (node.left &&
+      node.left.type === 'MemberExpression' &&
+      node.left.property &&
+      node.left.property.type === 'Identifier' &&
+      node.right &&
+      (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
+
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, node.left.property.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createPropertyFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+
+    // 处理 module.exports = { ... } 形式的导出
+    if (node.left &&
+      node.left.type === 'MemberExpression' &&
+      node.left.object &&
+      node.left.object.type === 'Identifier' &&
+      node.left.object.name === 'module' &&
+      node.left.property &&
+      node.left.property.type === 'Identifier' &&
+      node.left.property.name === 'exports' &&
+      node.right &&
+      node.right.type === 'ObjectExpression') {
+
+      // 检测对象字面量中的属性
+      for (var i = 0; i < node.right.properties.length; i++) {
+        var property = node.right.properties[i];
+        
+        // 处理简写属性（如 { AdminManager }）
+        if (property.shorthand && property.key && property.key.type === 'Identifier') {
+          // 先检测节点类型 - 使用属性节点而不是赋值表达式节点
+          var detected_type = this.detector.detectTypeOnly(property);
+
+          // 根据规则类型进行过滤
+          if (this._shouldSkipDetection(rule_type, detected_type)) {
+            continue;
+          }
+
+          var result = this.detector.detect(property, property.key.name);
+          if (result) {
+            result.node = property;
+            result.fix = this.fix.createPropertyFixFunction(context, property, result);
+            context.report(result);
+          }
+        }
+        
+        // 处理普通属性（如 { AdminManager: AdminManager }）
+        if (!property.shorthand && property.key && property.key.type === 'Identifier') {
+          // 先检测节点类型 - 使用属性节点而不是赋值表达式节点
+          var detected_type_normal = this.detector.detectTypeOnly(property);
+
+          // 根据规则类型进行过滤
+          if (this._shouldSkipDetection(rule_type, detected_type_normal)) {
+            continue;
+          }
+
+          var result_normal = this.detector.detect(property, property.key.name);
+          if (result_normal) {
+            result_normal.node = property;
+            result_normal.fix = this.fix.createPropertyFixFunction(context, property, result_normal);
+            context.report(result_normal);
+          }
+        }
+      }
+      
+      return;
+    }
+
+    // 处理函数导出
+    if (node.left &&
+      node.left.type === 'MemberExpression' &&
+      node.left.object &&
+      node.left.object.type === 'Identifier' &&
+      node.left.object.name === 'exports' &&
+      node.left.property &&
+      node.left.property.type === 'Identifier' &&
+      node.right &&
+      (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
+
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, node.left.property.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+
+    // 处理 module.exports = class user {} 形式的类导出
+    if (node.left &&
+      node.left.type === 'MemberExpression' &&
+      node.left.object &&
+      node.left.object.type === 'Identifier' &&
+      node.left.object.name === 'module' &&
+      node.left.property &&
+      node.left.property.type === 'Identifier' &&
+      node.left.property.name === 'exports' &&
+      node.right &&
+      node.right.type === 'ClassExpression') {
+
+      // 检测类表达式中的类名
+      if (node.right.id && node.right.id.type === 'Identifier') {
+        // 先检测节点类型
+        var detected_type = this.detector.detectTypeOnly(node);
+
+        // 根据规则类型进行过滤
+        if (this._shouldSkipDetection(rule_type, detected_type)) {
+          return;
+        }
+
+        var result = this.detector.detect(node, node.right.id.name);
+      if (result) {
+        result.node = node.right; // 传递ClassExpression节点而不是AssignmentExpression节点
+        result.fix = this.fix.createClassFixFunction(context, node.right, result);
+        context.report(result);
+      }
+      }
+    }
+  }
+
+  /**
+   * 处理方法定义节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleMethodDefinition(context, full_node, node, rule_type) {
+    // 先检测节点类型
+    var detected_type = this.detector.detectTypeOnly(node);
+
+    // 根据规则类型进行过滤
+    if (this._shouldSkipDetection(rule_type, detected_type)) {
+      return;
+    }
+
+    if (node.key && (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier')) {
+      var result = this.detector.detect(node, node.key.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createMethodFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理属性定义节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handlePropertyDefinition(context, full_node, node, rule_type) {
+    if (node.key && (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier')) {
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+      
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+      // 使用detect方法，它会自动检测类型
+      var result = this.detector.detect(node, node.key.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createPropertyFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理对象属性节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleObjectProperty(context, full_node, node, rule_type) {
+    if (node.key && node.key.type === 'Identifier') {
+      // 跳过解构赋值
+      if (this._isDestructuringProperty(node)) {
+        return;
+      }
+
+      // 跳过函数参数引用
+      if (this._isFunctionParamReference(node)) {
+        return;
+      }
+
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      // 使用detect方法，它会自动检测类型
+      var result = this.detector.detect(node, node.key.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createPropertyFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理函数声明节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleFunctionDeclaration(context, full_node, node, rule_type) {
+    // 先检测节点类型
+    var detected_type = this.detector.detectTypeOnly(node);
+
+    // 根据规则类型进行过滤
+    if (this._shouldSkipDetection(rule_type, detected_type)) {
+      return;
+    }
+
+    if (node.id && node.id.type === 'Identifier') {
+      var result = this.detector.detect(node, node.id.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理函数表达式节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleFunctionExpression(context, full_node, node, rule_type) {
+    // 先检测节点类型
+    var detected_type = this.detector.detectTypeOnly(node);
+
+    // 根据规则类型进行过滤
+    if (this._shouldSkipDetection(rule_type, detected_type)) {
+      return;
+    }
+
+    // 检测函数表达式本身的名称
+    if (node.id && node.id.type === 'Identifier') {
+      var result = this.detector.detect(node, node.id.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+
+    // 检测赋值给变量的函数表达式
+    if (node.parent && node.parent.type === 'VariableDeclarator' && node.parent.id && node.parent.id.type === 'Identifier') {
+      var result = this.detector.detect(node.parent, node.parent.id.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理箭头函数节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleArrowFunctionExpression(context, full_node, node, rule_type) {
+    // 先检测节点类型
+    var detected_type = this.detector.detectTypeOnly(node);
+
+    // 根据规则类型进行过滤
+    if (this._shouldSkipDetection(rule_type, detected_type)) {
+      return;
+    }
+
+    // 箭头函数通常没有名称，但可能有变量名
+    if (node.parent && node.parent.type === 'VariableDeclarator' && node.parent.id && node.parent.id.type === 'Identifier') {
+      var result = this.detector.detect(node.parent, node.parent.id.name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理函数调用节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleCallExpression(context, full_node, node, rule_type) {
+    // 先检测节点类型
+    var detected_type = this.detector.detectTypeOnly(node);
+
+    // 根据规则类型进行过滤
+    if (this._shouldSkipDetection(rule_type, detected_type)) {
+      return;
+    }
+
+    if (node.callee && node.callee.type === 'Identifier') {
+      var function_name = node.callee.name;
+
+      // 跳过混入函数调用
+      if (function_name === 'Loggable' || function_name === 'Serializable') {
+        return;
+      }
+
+      // 跳过JavaScript内置函数
+      var builtin_functions = [
+        'Symbol', 'Object', 'Array', 'String', 'Number', 'Boolean', 'Date',
+        'RegExp', 'Function', 'Error', 'Math', 'JSON', 'Promise', 'Map',
+        'Set', 'WeakMap', 'WeakSet', 'Proxy', 'Reflect', 'Intl', 'console',
+        'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'eval', 'encodeURI',
+        'decodeURI', 'encodeURIComponent', 'decodeURIComponent', 'setTimeout',
+        'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame',
+        'cancelAnimationFrame', 'alert', 'confirm', 'prompt', 'fetch',
+        'XMLHttpRequest', 'FormData', 'URL', 'URLSearchParams', 'Blob',
+        'File', 'FileReader', 'atob', 'btoa', 'crypto', 'performance'
+      ];
+
+      if (builtin_functions.includes(function_name)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, function_name);
+      if (result) {
+        // 再次检查过滤条件，确保检测到的类型和规则匹配
+        if (this._shouldSkipDetection(rule_type, result.original_type)) {
+          return;
+        }
+        result.node = full_node;
+        result.fix = this.fix.createFunctionFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 判断是否为解构赋值中的属性
+   * @param {object} node AST节点
+   * @returns {boolean} 是否为解构赋值属性
+   */
+  _isDestructuringProperty(node) {
+    var current_node = node;
+    while (current_node.parent) {
+      // 检查是否为解构赋值模式（变量声明）
+      if (current_node.parent.type === 'ObjectPattern' &&
+        current_node.parent.parent &&
+        current_node.parent.parent.type === 'VariableDeclarator') {
+        return true;
+      }
+
+      // 检查是否为函数参数中的解构参数
+      if (current_node.parent.type === 'ObjectPattern' &&
+        current_node.parent.parent &&
+        (current_node.parent.parent.type === 'FunctionDeclaration' ||
+          current_node.parent.parent.type === 'FunctionExpression' ||
+          current_node.parent.parent.type === 'ArrowFunctionExpression')) {
+        return true;
+      }
+
+      current_node = current_node.parent;
+    }
+    return false;
+  }
+
+  /**
+   * 判断是否为函数参数引用
+   * @param {object} node AST节点
+   * @returns {boolean} 是否为参数引用
+   */
+  _isParameterReference(node) {
+    var current_node = node;
+    while (current_node.parent) {
+      // 检查是否为函数体中的参数引用（在对象字面量中使用参数）
+      if (current_node.parent.type === 'ObjectExpression') {
+        var function_node = current_node.parent;
+        while (function_node.parent) {
+          if (function_node.parent.type === 'FunctionDeclaration' ||
+            function_node.parent.type === 'FunctionExpression' ||
+            function_node.parent.type === 'ArrowFunctionExpression') {
+            return true;
+          }
+          function_node = function_node.parent;
+        }
+      }
+      current_node = current_node.parent;
+    }
+    return false;
+  }
+
+  /**
+   * 判断是否为module.exports属性
+   * @param {object} node AST节点
+   * @returns {boolean} 是否为module.exports属性
+   */
+  _isModuleExportsProperty(node) {
+    var current_node = node;
+    while (current_node.parent) {
+      // 检查是否为 module.exports 对象字面量中的属性
+      if (current_node.parent.type === 'ObjectExpression') {
+        var obj_expr_node = current_node.parent;
+        while (obj_expr_node.parent) {
+          // 检查是否为 module.exports = { ... } 的情况
+          if (obj_expr_node.parent.type === 'AssignmentExpression' &&
+            obj_expr_node.parent.left &&
+            obj_expr_node.parent.left.type === 'MemberExpression' &&
+            obj_expr_node.parent.left.object &&
+            obj_expr_node.parent.left.object.type === 'Identifier' &&
+            obj_expr_node.parent.left.object.name === 'module' &&
+            obj_expr_node.parent.left.property &&
+            obj_expr_node.parent.left.property.type === 'Identifier' &&
+            obj_expr_node.parent.left.property.name === 'exports') {
+            return true;
+          }
+          obj_expr_node = obj_expr_node.parent;
+        }
+      }
+      current_node = current_node.parent;
+    }
+    return false;
+  }
+
+  /**
+   * 根据检测到的类型获取正确的规则类型
+   * @param {string} detected_type 检测到的类型
+   * @returns {string} 正确的规则类型
+   */
+  _getCorrectRuleType(detected_type) {
+    var type_mapping = {
+      'class': 'class',
+      'property-class': 'class',
+      'class-instance': 'class-instance',
+      'property-class-instance': 'class-instance',
+      'static-class-instance': 'class-instance',
+      'function': 'function',
+      'property-function': 'function',
+      'static-function': 'function',
+      'variable': 'variable',
+      'property-variable': 'variable',
+      'static-variable': 'variable',
+      'constant': 'constant',
+      'property-constant': 'constant',
+      'static-constant': 'constant',
+      'param': 'param'
+    };
+
+    return type_mapping[detected_type] || 'variable';
+  }
+
+  /**
+   * 判断是否应该跳过检测
+   * @param {string} rule_type 规则类型
+   * @param {string} detected_type 检测到的类型
+   * @returns {boolean} 是否跳过
+   */
+  _shouldSkipDetection(rule_type, detected_type) {
+    // 规则类型映射
+    var rule_type_mapping = {
+      'class': ['class', 'property-class'],
+      'class-instance': ['class-instance', 'property-class-instance', 'static-class-instance', 'prototype-class-instance', 'internal-class-instance'],
+      'function': ['function', 'property-function', 'static-function', 'prototype-function', 'private-function', 'internal-function'],
+      'variable': ['variable', 'property-variable', 'static-variable', 'prototype-variable', 'private-variable', 'internal-variable'],
+      'constant': ['constant', 'property-constant', 'static-constant', 'prototype-constant'],
+      'param': ['param']
+    };
+
+    // 如果规则类型不在映射中，不跳过
+    if (!rule_type_mapping[rule_type]) {
+      return false;
+    }
+
+    // 特殊处理：类实例类型只能被class-instance规则检测
+    if (detected_type && detected_type.includes('class-instance')) {
+      return rule_type !== 'class-instance';
+    }
+
+    // 特殊处理：函数类型只能被function规则检测
+    if (detected_type && detected_type.includes('function')) {
+      return rule_type !== 'function';
+    }
+
+    // 特殊处理：类类型只能被class规则检测
+    if (detected_type && detected_type.includes('class') && !detected_type.includes('class-instance')) {
+      return rule_type !== 'class';
+    }
+
+    // 特殊处理：常量类型只能被constant规则检测
+    if (detected_type && detected_type.includes('constant')) {
+      return rule_type !== 'constant';
+    }
+
+    // 特殊处理：变量类型只能被variable规则检测
+    if (detected_type && detected_type.includes('variable')) {
+      return rule_type !== 'variable';
+    }
+
+    // 如果检测到的类型不属于该规则应该检测的类型，则跳过
+    return !rule_type_mapping[rule_type].includes(detected_type);
+  }
+
+  /**
+   * 处理导出默认声明节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleExportDefaultDeclaration(context, full_node, node, rule_type) {
+    if (node.declaration && node.declaration.type === 'ClassDeclaration') {
+      // 检测导出的类名
+      if (node.declaration.id && node.declaration.id.type === 'Identifier') {
+        // 先检测节点类型
+        var detected_type = this.detector.detectTypeOnly(node.declaration);
+
+        // 根据规则类型进行过滤
+        if (this._shouldSkipDetection(rule_type, detected_type)) {
+          return;
+        }
+
+        var result = this.detector.detect(node.declaration, node.declaration.id.name);
+        if (result) {
+          result.node = full_node;
+          result.fix = this.fix.createVariableFixFunction(context, full_node, result);
+          context.report(result);
+        }
+      }
+    }
+  }
+
+  /**
+   * 处理导出命名声明节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleExportNamedDeclaration(context, full_node, node, rule_type) {
+    if (node.declaration && node.declaration.type === 'ClassDeclaration') {
+      // 检测导出的类名
+      if (node.declaration.id && node.declaration.id.type === 'Identifier') {
+        // 先检测节点类型
+        var detected_type = this.detector.detectTypeOnly(node.declaration);
+
+        // 根据规则类型进行过滤
+        if (this._shouldSkipDetection(rule_type, detected_type)) {
+          return;
+        }
+
+        var result = this.detector.detect(node.declaration, node.declaration.id.name);
+        if (result) {
+          result.node = full_node;
+          result.fix = this.fix.createClassFixFunction(context, full_node, result);
+          context.report(result);
+        }
+      }
+    }
+  }
+
+  /**
+   * 处理类表达式节点
+   * @param {object} context ESLint上下文
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleClassExpression(context, full_node, node, rule_type) {
+    // 检测类表达式本身的名称
+    if (node.id && node.id.type === 'Identifier') {
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, node.id.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createClassFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理导入声明节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleImportDeclaration(context, full_node, node, rule_type) {
+    // 检测导入的类名
+    if (node.specifiers && node.specifiers.length > 0) {
+      for (var i = 0; i < node.specifiers.length; i++) {
+        var specifier = node.specifiers[i];
+
+        // 检测导入的类名
+        if (specifier.imported && specifier.imported.type === 'Identifier') {
+          // 先检测节点类型
+          var detected_type = this.detector.detectTypeOnly(node);
+
+          // 根据规则类型进行过滤
+          if (this._shouldSkipDetection(rule_type, detected_type)) {
+            continue;
+          }
+
+          var result = this.detector.detect(node, specifier.imported.name);
+          if (result) {
+            result.node = full_node;
+            result.fix = this.fix.createVariableFixFunction(context, full_node, result);
+            context.report(result);
+          }
+        }
+
+        // 检测默认导入的类名
+        if (specifier.type === 'ImportDefaultSpecifier' && specifier.local) {
+          // 先检测节点类型
+          var detected_type_default = this.detector.detectTypeOnly(node);
+
+          // 根据规则类型进行过滤
+          if (this._shouldSkipDetection(rule_type, detected_type_default)) {
+            continue;
+          }
+
+          var result_default = this.detector.detect(node, specifier.local.name);
+          if (result_default) {
+            this.report(context, full_node, result_default);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * 处理标识符节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleIdentifier(context, full_node, node, rule_type) {
+    // 检测类引用中的标识符
+    if (node.parent && node.parent.type === 'ClassDeclaration') {
+      // 先检测节点类型
+      var detected_type = this.detector.detectTypeOnly(node);
+
+      // 根据规则类型进行过滤
+      if (this._shouldSkipDetection(rule_type, detected_type)) {
+        return;
+      }
+
+      var result = this.detector.detect(node, node.name);
+      if (result) {
+        result.node = full_node;
+        result.fix = this.fix.createMethodFixFunction(context, full_node, result);
+        context.report(result);
+      }
+    }
+  }
+
+  /**
+   * 处理对象表达式节点
+   * @param {object} context ESLint上下文
+   * @param {object} full_node 完整AST节点
+   * @param {object} node AST节点
+   * @param {string} rule_type 规则类型
+   */
+  handleObjectExpression(context, full_node, node, rule_type) {
+    // 遍历对象的所有属性
+    if (node.properties && node.properties.length > 0) {
+      for (var i = 0; i < node.properties.length; i++) {
+        var property = node.properties[i];
+
+        // 只处理普通属性，跳过解构赋值等
+        if (property.type === 'Property' && property.key && property.key.type === 'Identifier') {
+          // 调用handleProperty方法处理每个属性
+          this.handleProperty(context, full_node, property, rule_type);
+        }
+      }
+    }
+  }
+}
+
+module.exports = { Handler };