mm_eslint 1.4.5 → 1.4.7

package/handler.js

@@ -1,993 +0,0 @@
-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 };