mm_eslint 1.4.5 → 1.4.7

package/detector.js

@@ -1,1291 +0,0 @@
-const { Validator } = require('./validator');
-const { Corrector } = require('./corrector');
-const { Tip } = require('./tip');
-
-/**
- * 类型检测器类
- * 负责根据AST节点推断命名类型
- */
-class Detector {
-  /**
-   * 构造函数
-   * @param {object} config 配置对象
-   */
-  constructor(config) {
-    this.config = config;
-    this.validator = new Validator(config);
-    this.corrector = new Corrector(config);
-    this.tip = new Tip(config);
-  }
-
-  /**
-   * 检测类声明类型
-   * @param {object} node AST节点
-   * @returns {string} 类型名称
-   */
-  detectClassType(node) {
-    if (node.type === 'ClassDeclaration') {
-      return 'class';
-    }
-
-    if (node.type === 'ClassExpression') {
-      return 'class';
-    }
-
-    if (node.type === 'VariableDeclaration' &&
-      node.declarations &&
-      node.declarations.length > 0 &&
-      node.declarations[0].init &&
-      node.declarations[0].init.type === 'ClassExpression') {
-      return 'class';
-    }
-
-    if (node.type === 'AssignmentExpression' && node.right && node.right.type === 'ClassExpression') {
-      return 'class';
-    }
-
-    if (node.type === 'Property' && node.value && node.value.type === 'ClassExpression') {
-      return 'property-class';
-    }
-
-    // 处理 module.exports = class user_manager {} 这种形式
-    if (node.type === 'AssignmentExpression' &&
-      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') {
-      return 'class';
-    }
-
-    // 处理 module.exports = { Admin: Admin, AdminManager } 这种形式的引用
-    if ((node.type === 'Property' || node.type === 'ObjectProperty') && node.key && node.key.type === 'Identifier') {
-      // 检查是否在导出语句的上下文中
-      var parent = node.parent;
-      if (parent && parent.type === 'ObjectExpression') {
-        var grand_parent = parent.parent;
-        if (grand_parent && grand_parent.type === 'AssignmentExpression' &&
-          grand_parent.left && grand_parent.left.type === 'MemberExpression' &&
-          grand_parent.left.object && grand_parent.left.object.type === 'Identifier' &&
-          grand_parent.left.object.name === 'module' &&
-          grand_parent.left.property && grand_parent.left.property.type === 'Identifier' &&
-          grand_parent.left.property.name === 'exports') {
-          
-          // 通用类型溯源：对于导出语句中的属性，溯源其引用的类型
-          var traced_type = this._traceReferenceType(node);
-          if (traced_type) {
-            return traced_type;
-          }
-          
-          // 如果无法溯源到具体类型，返回null让其他检测器处理
-          return null;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 检测类实例类型
-   * @param {object} node AST节点
-   * @returns {string} 类型名称
-   */
-  detectClassInstanceType(node) {
-    // VariableDeclaration 中的 new 表达式
-    if (node.type === 'VariableDeclaration') {
-      if (node.declarations && node.declarations.length > 0) {
-        var decl = node.declarations[0];
-        if (decl.init && decl.init.type === 'NewExpression') {
-          return 'class-instance';
-        }
-      }
-    }
-
-    if (node.type === 'Property' && node.value && node.value.type === 'NewExpression') {
-      return 'property-class-instance';
-    }
-
-    if (node.type === 'AssignmentExpression' && node.right && node.right.type === 'NewExpression') {
-      return 'property-class-instance';
-    }
-
-    if (node.type === 'PropertyDefinition' && node.key && node.value && node.value.type === 'NewExpression') {
-      // 判断是否是私有字段
-      if (node.key.type === 'PrivateIdentifier') {
-        return 'private-class-instance';
-      }
-      return node.static ? 'static-class-instance' : 'property-class-instance';
-    }
-
-    // 正则表达式字面量视为类实例
-    if (node.type === 'VariableDeclaration') {
-      if (node.declarations && node.declarations.length > 0) {
-        var decl = node.declarations[0];
-        if (decl.init && decl.init.type === 'Literal' && decl.init.regex) {
-          return 'class-instance';
-        }
-      }
-    }
-
-    if (node.type === 'Property' && node.value && node.value.type === 'Literal' && node.value.regex) {
-      return 'property-class-instance';
-    }
-
-    return null;
-  }
-
-  /**
-   * 检测函数类型
-   * @param {object} node AST节点
-   * @returns {string} 类型名称
-   */
-  detectFunctionType(node) {
-    if (node.type === 'FunctionDeclaration') {
-      return 'function';
-    }
-
-    // 检测函数表达式内部的函数名
-    if (node.type === 'FunctionExpression' && node.id && node.id.type === 'Identifier') {
-      return 'function';
-    }
-
-    if (node.type === 'VariableDeclaration' && node.declarations && node.declarations.length > 0) {
-      var decl = node.declarations[0];
-      if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
-        return 'function';
-      }
-    }
-
-    // 检测VariableDeclarator节点中的箭头函数
-    if (node.type === 'VariableDeclarator' && node.init &&
-      (node.init.type === 'FunctionExpression' || node.init.type === 'ArrowFunctionExpression')) {
-      return 'function';
-    }
-
-    if (node.type === 'Property' && node.value &&
-      (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
-      return 'property-function';
-    }
-
-    if (node.type === 'MethodDefinition') {
-      // 检测私有方法（ES6私有方法语法 # 前缀）
-      if (node.key && node.key.type === 'PrivateIdentifier') {
-        return 'private-function';
-      }
-
-      // 检测传统私有方法约定（_ 前缀）
-      if (node.key && node.key.type === 'Identifier' && node.key.name.startsWith('_')) {
-        return node.static ? 'static-function' : 'internal-function';
-      }
-
-      return node.static ? 'static-function' : 'function';
-    }
-
-    if (node.type === 'PropertyDefinition' && node.value &&
-      (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
-      return node.static ? 'static-function' : 'property-function';
-    }
-
-    if (node.type === 'AssignmentExpression' && node.right &&
-      (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
-      return 'property-function';
-    }
-
-    if (node.type === 'CallExpression' && node.callee && node.callee.type === 'Identifier') {
-      // 函数调用应该被识别为函数使用，而不是函数定义
-      return 'use-function';
-    }
-
-    return null;
-  }
-
-  /**
-   * 检测变量类型
-   * @param {object} node AST节点
-   * @returns {string} 类型名称
-   */
-  detectVariableType(node) {
-    // let/var 声明
-    if (node.type === 'VariableDeclaration' && (node.kind === 'let' || node.kind === 'var')) {
-      return 'variable';
-    }
-
-    // for 循环中的变量
-    if (node.type === 'ForStatement' && node.init && node.init.type === 'VariableDeclaration' &&
-      (node.init.kind === 'let' || node.init.kind === 'var')) {
-      return 'variable';
-    }
-
-    // 对象属性变量 - 先排除函数类型和常量属性
-    if ((node.type === 'Property' || node.type === 'ObjectProperty')) {
-      // 如果是函数类型，不应该识别为变量
-      if (node.value && (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
-        return null;
-      }
-      // 属性简写（如 { user_name }）应该识别为变量
-      if (node.shorthand && node.value && node.value.type === 'Identifier') {
-        return 'property-variable';
-      }
-      // 只有字面量值且不是常量属性才识别为变量
-      if (this._isLiteralValue(node.value)) {
-        // 检查是否为常量属性（父级是const声明）
-        var parent_type = this._getParentDeclarationType(node);
-        if (parent_type !== 'const') {
-          return 'property-variable';
-        }
-      }
-    }
-
-    // 类属性变量
-    if (node.type === 'PropertyDefinition' && this._isLiteralValue(node.value)) {
-      return node.static ? 'static-variable' : 'property-variable';
-    }
-
-    // 赋值表达式
-    if (node.type === 'AssignmentExpression' && this._isLiteralValue(node.right)) {
-      return 'property-variable';
-    }
-
-    return null;
-  }
-
-  /**
-   * 检测声明方式问题
-   * @param {object} node AST节点
-   * @returns {string} 问题类型
-   */
-  detectDeclarationIssue(node) {
-    // const 声明但包含非基础字面量 - 应该用let而不是const
-    if (node.type === 'VariableDeclaration' && node.kind === 'const') {
-      if (node.declarations && node.declarations.length > 0) {
-        var decl = node.declarations[0];
-        if (decl.init && !this._isBasicLiteralValue(decl.init)) {
-          // 排除函数表达式和箭头函数表达式，它们应该使用const声明
-          if (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression') {
-            return null;
-          }
-          return 'const-should-be-let';
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 检测常量类型
-   * @param {object} node AST节点
-   * @returns {string} 类型名称
-   */
-  detectConstantType(node) {
-    // const 声明 - 当右侧是字面量值（包括对象和数组）时视为常量
-    if (node.type === 'VariableDeclaration' && node.kind === 'const') {
-      // 检查右侧是否是字面量值
-      if (node.declarations && node.declarations.length > 0) {
-        var decl = node.declarations[0];
-        if (decl.init && this._isLiteralValue(decl.init)) {
-          return 'constant';
-        }
-      }
-    }
-
-    // var 和 let 声明应该被识别为变量，而不是常量
-    if (node.type === 'VariableDeclaration' && (node.kind === 'var' || node.kind === 'let')) {
-      return null; // 返回null，让其他检测器处理
-    }
-
-    // 对象属性常量 - 只有当父级是const声明且属性值是字面量时才视为常量
-    if ((node.type === 'Property' || node.type === 'ObjectProperty')) {
-      // 只有当值是字面量时才视为常量
-      if (this._isLiteralValue(node.value)) {
-        var parent_type = this._getParentDeclarationType(node);
-        if (parent_type === 'const') {
-          return 'property-constant';
-        }
-      }
-    }
-
-    // 类属性常量 - 只有当属性名符合常量命名规范时才识别为常量
-    if (node.type === 'PropertyDefinition' && this._isLiteralValue(node.value)) {
-      if (node.static) {
-        return 'static-variable';
-      }
-      // 类中的静态属性应该被识别为静态属性-变量，而不是静态属性-常量
-      return 'variable';
-    }
-
-    return null;
-  }
-
-  /**
-   * 检测参数类型
-   * @param {object} node AST节点
-   * @returns {string} 类型名称
-   */
-  detectParamType(node) {
-    // 只在真正的函数参数节点上返回参数类型
-    if (node.type === 'Identifier' && node.parent &&
-      (node.parent.type === 'FunctionDeclaration' ||
-        node.parent.type === 'FunctionExpression' ||
-        node.parent.type === 'ArrowFunctionExpression') &&
-      node.parent.params && node.parent.params.includes(node)) {
-
-      // 增强版参数类型检测：根据使用上下文推断参数类型
-      var param_type = this._inferParamTypeFromContext(node);
-
-      // 如果使用上下文无法推断，尝试其他方法
-      if (!param_type) {
-        // 基于命名约定推断（优先级高于命名风格）
-        param_type = this._inferParamTypeByNamingConvention(node.name);
-
-        // 如果命名约定也无法推断，基于命名风格推断
-        if (!param_type) {
-          param_type = this._inferParamTypeByStyle(node.name);
-        }
-      }
-
-      // 对于箭头函数参数，优先推断为变量类型
-      if (node.parent && node.parent.type === 'ArrowFunctionExpression') {
-        param_type = 'variable';
-      }
-      return param_type ? 'param-' + param_type : 'param';
-    }
-
-    // 不是参数节点，返回null让其他检测器处理
-    return null;
-  }
-
-  /**
-   * 根据上下文推断参数类型
-   * @param {object} param_node 参数节点
-   * @returns {string} 参数类型（function/class/variable）
-   */
-  _inferParamTypeFromContext(param_node) {
-    var function_node = param_node.parent;
-    var param_name = param_node.name;
-
-    // 如果没有函数体，无法进行使用上下文推断
-    if (!function_node.body) {
-      return null; // 无法推断，返回null让上层逻辑处理
-    }
-
-    // 收集参数在函数体中的所有使用方式
-    var usage_types = [];
-
-    this._traverseFunctionBody(function_node.body, function (node) {
-      // 检查调用表达式：param_name() → 函数类型
-      if (node.type === 'CallExpression' &&
-        node.callee.type === 'Identifier' &&
-        node.callee.name === param_name) {
-        usage_types.push('function_call');
-      }
-
-      // 检查new表达式：new param_name() → 类类型
-      else if (node.type === 'NewExpression' &&
-        node.callee.type === 'Identifier' &&
-        node.callee.name === param_name) {
-        usage_types.push('class_instantiation');
-      }
-
-      // 检查成员表达式：param_name.property → 对象类型
-      else if (node.type === 'MemberExpression' &&
-        node.object.type === 'Identifier' &&
-        node.object.name === param_name) {
-        usage_types.push('property_access');
-      }
-
-      // 检查方法调用：param_name.method() → 对象类型（类实例）
-      else if (node.type === 'CallExpression' &&
-        node.callee.type === 'MemberExpression' &&
-        node.callee.object.type === 'Identifier' &&
-        node.callee.object.name === param_name) {
-        usage_types.push('method_call');
-      }
-
-      // 检查赋值表达式：var x = param_name → 变量类型
-      else if (node.type === 'VariableDeclarator' &&
-        node.init && node.init.type === 'Identifier' &&
-        node.init.name === param_name) {
-        usage_types.push('variable_assignment');
-      }
-
-      // 检查作为参数传递：func(param_name) → 根据接收函数的上下文推断
-      else if (node.type === 'CallExpression') {
-        for (var i = 0; i < node.arguments.length; i++) {
-          var arg = node.arguments[i];
-          if (arg.type === 'Identifier' && arg.name === param_name) {
-            usage_types.push('function_argument');
-          }
-        }
-      }
-
-      // 检查直接使用：return name, var x = name → 变量类型
-      else if (node.type === 'Identifier' && node.name === param_name) {
-        // 排除已经在其他检测中处理的情况
-        var parent = node.parent;
-        if (!parent ||
-          (parent.type !== 'CallExpression' &&
-            parent.type !== 'NewExpression' &&
-            parent.type !== 'MemberExpression' &&
-            !(parent.type === 'VariableDeclarator' && parent.init === node))) {
-          usage_types.push('direct_usage');
-        }
-      }
-
-      return false; // 继续遍历，收集所有使用方式
-    });
-
-    // 根据使用方式推断参数类型
-    return this._inferTypeFromUsage(usage_types, param_name);
-  }
-
-  /**
-   * 根据使用方式推断参数类型
-   * @param {Array} usage_types 使用方式数组
-   * @param {string} param_name 参数名
-   * @returns {string} 推断的参数类型
-   */
-  _inferTypeFromUsage(usage_types, param_name) {
-    // 如果没有使用方式，无法推断
-    if (usage_types.length === 0) {
-      return null;
-    }
-
-    // 优先级：函数调用 > 类实例化 > 方法调用 > 属性访问 > 函数参数 > 变量赋值 > 直接使用
-    var priority_map = {
-      'function_call': 7,      // 最高优先级：明确是函数
-      'class_instantiation': 6, // 高优先级：明确是类
-      'method_call': 5,        // 中高优先级：方法调用（类实例）
-      'property_access': 4,     // 中优先级：对象属性访问
-      'function_argument': 3,   // 低优先级：作为函数参数传递（根据接收函数推断）
-      'variable_assignment': 2, // 较低优先级：变量赋值
-      'direct_usage': 1         // 最低优先级：直接使用
-    };
-
-    // 找到最高优先级的用法
-    var highest_priority = 0;
-    var inferred_type = null;
-
-    for (var i = 0; i < usage_types.length; i++) {
-      var usage = usage_types[i];
-      var priority = priority_map[usage] || 0;
-
-      if (priority > highest_priority) {
-        highest_priority = priority;
-
-        // 根据使用方式映射到参数类型
-        switch (usage) {
-          case 'function_call':
-            inferred_type = 'function';
-            break;
-          case 'class_instantiation':
-            inferred_type = 'class';
-            break;
-          case 'method_call':
-            inferred_type = 'class-instance';
-            break;
-          case 'property_access':
-            inferred_type = 'object';
-            break;
-          case 'function_argument':
-            // 作为函数参数传递，需要根据接收函数的上下文推断
-            inferred_type = 'variable';  // 默认变量类型，让其他使用方式覆盖
-            break;
-          case 'variable_assignment':
-          case 'direct_usage':
-            inferred_type = 'variable';
-            break;
-        }
-      }
-    }
-
-    return inferred_type;
-  }
-
-  /**
-   * 基于命名约定推断参数类型
-   * @param {string} param_name 参数名
-   * @returns {string} 推断的参数类型
-   */
-  _inferParamTypeByNamingConvention(param_name) {
-    var lower_name = param_name.toLowerCase();
-
-    // 函数类型命名约定
-    if (lower_name.startsWith('on') ||
-      lower_name.startsWith('handle') ||
-      lower_name.endsWith('func') ||
-      lower_name.endsWith('callback') ||
-      lower_name.endsWith('handler')) {
-      return 'function';
-    }
-
-    // 类类型命名约定
-    if (lower_name.endsWith('manager') ||
-      lower_name.endsWith('service') ||
-      lower_name.endsWith('controller') ||
-      lower_name.endsWith('provider') ||
-      lower_name.endsWith('factory') ||
-      lower_name.endsWith('class') ||
-      lower_name.endsWith('model') ||
-      lower_name.endsWith('view') ||
-      lower_name.endsWith('component')) {
-      return 'class';
-    }
-
-    // 对象类型命名约定
-    if (lower_name.endsWith('obj') ||
-      lower_name.endsWith('object') ||
-      lower_name.endsWith('data') ||
-      lower_name.endsWith('info') ||
-      lower_name.endsWith('config') ||
-      lower_name.endsWith('options')) {
-      return 'variable';
-    }
-
-    return null;
-  }
-
-  /**
-   * 基于命名风格推断参数类型
-   * @param {string} param_name 参数名
-   * @returns {string} 推断的参数类型
-   */
-  _inferParamTypeByStyle(param_name) {
-    var config = this.config || new (require('./config').Config)();
-
-    // 检查是否符合PascalCase（类类型）
-    if (config.getRegex('PascalCase').test(param_name)) {
-      return 'class';
-    }
-
-    // 检查是否符合snake_case（变量/对象类型）
-    if (config.getRegex('snake_case').test(param_name)) {
-      return 'variable';
-    }
-
-    // 检查是否符合camelCase（函数类型）
-    if (config.getRegex('camelCase').test(param_name)) {
-      return 'function';
-    }
-
-    // 默认变量类型
-    return 'variable';
-  }
-
-  /**
-   * 语义推断参数类型
-   * @param {object} param_node 参数节点
-   * @returns {string} 推断的参数类型
-   */
-  _inferParamTypeSemantically(param_node) {
-    var function_node = param_node.parent;
-    var param_name = param_node.name;
-
-    // 收集函数体中所有标识符
-    var identifiers = [];
-    this._traverseFunctionBody(function_node.body, function (node) {
-      if (node.type === 'Identifier') {
-        identifiers.push({
-          name: node.name,
-          type: this._getIdentifierUsageType(node),
-          node: node
-        });
-      }
-      return false;
-    }.bind(this));
-
-    // 分析标识符与参数的语义关联
-    for (var i = 0; i < identifiers.length; i++) {
-      var identifier = identifiers[i];
-
-      // 检查标识符是否与参数名称有语义关联
-      if (this._hasSemanticRelation(param_name, identifier.name)) {
-        // 根据标识符的使用类型推断参数类型
-        switch (identifier.type) {
-          case 'function_call':
-            return 'function';
-          case 'class_instantiation':
-            return 'class';
-          case 'property_access':
-            return 'class-instance';
-          case 'variable_declaration':
-            return 'variable';
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 检查两个标识符是否有语义关联
-   * @param {string} param_name 参数名
-   * @param {string} identifier_name 标识符名
-   * @returns {boolean} 是否有语义关联
-   */
-  _hasSemanticRelation(param_name, identifier_name) {
-    // 简单的语义关联规则
-
-    // 1. 名称相似性检查（忽略大小写和下划线）
-    var normalized_param = param_name.toLowerCase().replace(/[_-]/g, '');
-    var normalized_ident = identifier_name.toLowerCase().replace(/[_-]/g, '');
-
-    if (normalized_param === normalized_ident) {
-      return true;
-    }
-
-    // 2. 包含关系检查
-    if (normalized_ident.includes(normalized_param) ||
-      normalized_param.includes(normalized_ident)) {
-      return true;
-    }
-
-    // 3. 词根相似性检查
-    var param_root = this._getWordRoot(normalized_param);
-    var ident_root = this._getWordRoot(normalized_ident);
-
-    if (param_root && ident_root && param_root === ident_root) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * 获取标识符的使用类型
-   * @param {object} identifier_node 标识符节点
-   * @returns {string} 使用类型
-   */
-  _getIdentifierUsageType(identifier_node) {
-    var parent = identifier_node.parent;
-
-    if (parent.type === 'CallExpression' && parent.callee === identifier_node) {
-      return 'function_call';
-    }
-
-    if (parent.type === 'NewExpression' && parent.callee === identifier_node) {
-      return 'class_instantiation';
-    }
-
-    if (parent.type === 'MemberExpression' && parent.object === identifier_node) {
-      return 'property_access';
-    }
-
-    if (parent.type === 'VariableDeclarator' && parent.id === identifier_node) {
-      return 'variable_declaration';
-    }
-
-    return 'other';
-  }
-
-  /**
-   * 获取单词的词根（简化实现）
-   * @param {string} word 单词
-   * @returns {string} 词根
-   */
-  _getWordRoot(word) {
-    // 简单的词根提取规则
-    var common_suffixes = ['s', 'es', 'ed', 'ing', 'er', 'or', 'ment', 'tion', 'ity'];
-
-    for (var i = 0; i < common_suffixes.length; i++) {
-      var suffix = common_suffixes[i];
-      if (word.endsWith(suffix) && word.length > suffix.length) {
-        return word.slice(0, -suffix.length);
-      }
-    }
-
-    return word;
-  }
-
-  /**
-   * 遍历函数体
-   * @param {object} body_node 函数体节点
-   * @param {function} visitor 访问器函数
-   */
-  _traverseFunctionBody(body_node, visitor) {
-    if (!body_node || !visitor) return;
-
-    // 简单的AST遍历实现
-    var nodes_to_visit = [body_node];
-
-    while (nodes_to_visit.length > 0) {
-      var current_node = nodes_to_visit.pop();
-
-      // 调用访问器，如果返回true则停止遍历
-      if (visitor(current_node)) {
-        return;
-      }
-
-      // 添加子节点到遍历队列
-      if (current_node.body) {
-        if (Array.isArray(current_node.body)) {
-          nodes_to_visit.push(...current_node.body.reverse());
-        } else {
-          nodes_to_visit.push(current_node.body);
-        }
-      }
-
-      if (current_node.expression) {
-        nodes_to_visit.push(current_node.expression);
-      }
-
-      if (current_node.consequent) {
-        nodes_to_visit.push(current_node.consequent);
-      }
-
-      if (current_node.alternate) {
-        nodes_to_visit.push(current_node.alternate);
-      }
-
-      if (current_node.argument) {
-        nodes_to_visit.push(current_node.argument);
-      }
-
-      if (current_node.arguments && Array.isArray(current_node.arguments)) {
-        nodes_to_visit.push(...current_node.arguments.reverse());
-      }
-
-      if (current_node.elements && Array.isArray(current_node.elements)) {
-        nodes_to_visit.push(...current_node.elements.reverse());
-      }
-
-      if (current_node.properties && Array.isArray(current_node.properties)) {
-        nodes_to_visit.push(...current_node.properties.reverse());
-      }
-    }
-  }
-
-  /**
-   * 检测命名类型
-   * @param {object} node AST节点
-   * @param {string} name 名称
-   * @returns {object} 检测结果
-   */
-  detect(node, name) {
-    var type = null;
-
-    // 按优先级检测类型 - 变量检测应该在常量检测之前
-    var detectors = [
-      this.detectClassType.bind(this),
-      this.detectClassInstanceType.bind(this),
-      this.detectFunctionType.bind(this),  // 函数检测应该在变量检测之前
-      this.detectConstantType.bind(this),   // 常量检测优先级提高
-      this.detectVariableType.bind(this),   // 变量检测优先级降低
-      this.detectParamType.bind(this)
-    ];
-
-    for (var i = 0; i < detectors.length; i++) {
-      type = detectors[i](node);
-      if (type) {
-        break;
-      }
-    }
-
-    // 如果检测到类实例、函数等特殊类型，跳过声明问题检测
-    if (type && (type.includes('class-instance') || type.includes('function'))) {
-      // 跳过声明问题检测，直接进行命名规范验证
-    } else {
-      // 检测声明方式问题（优先级较低）
-      var original_type = this.detectDeclarationIssue(node);
-      if (original_type) {
-        // 如果是声明方式问题，直接返回相应的错误，不进行命名规范验证
-        var message = this.tip.getDeclarationIssueMessage(original_type, name);
-        return {
-          name,
-          node,
-          message,
-          error_type: 'declaration',
-          severity: 'error',
-          fix_suggestion: null,
-          original_type
-        };
-      }
-    }
-
-    if (!type) {
-      type = 'variable'; // 默认类型
-    }
-
-    var error = this.validator.validate(name, type);
-    if (!error) {
-      return null;
-    }
-
-    var fix_suggestion = this.corrector.getSuggestion(error);
-    var message = this.tip.getFullMessage(error, fix_suggestion);
-
-    return {
-      name,
-      node,
-      message,
-      error_type: error.type,
-      severity: error.severity,
-      fix_suggestion: fix_suggestion,
-      original_type: type
-    };
-  }
-
-  /**
-   * 检测命名类型（仅返回类型，不验证）
-   * @param {object} node AST节点
-   * @returns {string} 检测到的类型
-   */
-  detectTypeOnly(node) {
-    var type = null;
-
-    // 按优先级检测类型 - 变量检测应该在常量检测之前
-    var detectors = [
-      this.detectClassType.bind(this),
-      this.detectClassInstanceType.bind(this),
-      this.detectFunctionType.bind(this),  // 函数检测应该在变量检测之前
-      this.detectConstantType.bind(this),   // 常量检测优先级提高
-      this.detectVariableType.bind(this),   // 变量检测优先级降低
-      this.detectParamType.bind(this)
-    ];
-
-    for (var i = 0; i < detectors.length; i++) {
-      type = detectors[i](node);
-      if (type) {
-        break;
-      }
-    }
-
-    // 特殊处理：属性简写应该识别为变量，而不是常量
-    if (node.type === 'Property' && node.shorthand && node.value && node.value.type === 'Identifier') {
-      // 如果是属性简写，强制识别为变量
-      type = 'property-variable';
-    }
-
-    if (!type) {
-      type = 'variable'; // 默认类型
-    }
-
-    return type;
-  }
-
-  /**
-   * 判断是否为字面量值
-   * @param {object} node AST节点
-   * @returns {boolean} 是否为字面量
-   */
-  _isLiteralValue(node) {
-    if (!node) {
-      return false;
-    }
-
-    switch (node.type) {
-      case 'Literal':
-        return !node.regex; // 排除正则表达式
-      case 'TemplateLiteral':
-        return true;
-      case 'Identifier':
-        var literal_identifiers = ['undefined', 'null', 'Infinity', 'NaN', 'true', 'false'];
-        return literal_identifiers.includes(node.name);
-      case 'ArrayExpression':
-        if (node.elements && node.elements.length > 0) {
-          for (var i = 0; i < node.elements.length; i++) {
-            if (!this._isLiteralValue(node.elements[i])) {
-              return false;
-            }
-          }
-        }
-        return true;
-      case 'ObjectExpression':
-        if (node.properties && node.properties.length > 0) {
-          for (var i = 0; i < node.properties.length; i++) {
-            var property = node.properties[i];
-            if (property.value && !this._isLiteralValue(property.value)) {
-              return false;
-            }
-          }
-        }
-        return true;
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * 判断字符串是否符合PascalCase命名规范
-   * @param {string} name 名称
-   * @returns {boolean} 是否符合PascalCase
-   */
-  _isPascalCase(name) {
-    if (!name || name.length === 0) {
-      return false;
-    }
-    
-    // PascalCase要求首字母大写，后续字母可以大小写混合
-    // 但不能包含下划线或连字符
-    if (name.includes('_') || name.includes('-')) {
-      return false;
-    }
-    
-    // 首字母必须是大写字母
-    if (!/^[A-Z]/.test(name)) {
-      return false;
-    }
-    
-    // 整体必须符合标识符规范
-    if (!/^[A-Za-z][A-Za-z0-9]*$/.test(name)) {
-      return false;
-    }
-    
-    return true;
-  }
-
-  /**
-   * 检查属性名是否在作用域内有对应的类实例变量声明
-   * @param {string} name 属性名
-   * @param {object} node AST节点
-   * @returns {boolean} 是否是类实例引用
-   */
-  _isClassInstanceReference(name, node) {
-    if (!name || !node) {
-      return false;
-    }
-    
-    // 遍历AST查找变量声明
-    var current_node = node;
-    while (current_node.parent) {
-      current_node = current_node.parent;
-      
-      // 查找变量声明
-      if (current_node.type === 'VariableDeclaration') {
-        for (var i = 0; i < current_node.declarations.length; i++) {
-          var decl = current_node.declarations[i];
-          if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
-            // 检查是否为类实例声明（new表达式）
-            if (decl.init && decl.init.type === 'NewExpression') {
-              return true;
-            }
-          }
-        }
-      }
-      
-      // 查找赋值表达式
-      if (current_node.type === 'AssignmentExpression' && 
-          current_node.left && current_node.left.type === 'Identifier' && 
-          current_node.left.name === name) {
-        // 检查是否为类实例赋值（new表达式）
-        if (current_node.right && current_node.right.type === 'NewExpression') {
-          return true;
-        }
-      }
-      
-      // 如果到达程序根节点，停止搜索
-      if (current_node.type === 'Program') {
-        break;
-      }
-    }
-    
-    return false;
-  }
-
-  /**
-   * 通用类型溯源：对于导出语句中的属性，溯源其引用的类型
-   * @param {object} node 属性节点
-   * @returns {string} 溯源到的类型，无法溯源则返回null
-   */
-  _traceReferenceType(node) {
-    if (!node || !node.key || node.key.type !== 'Identifier') {
-      return null;
-    }
-    
-    // 对于简写属性 { AdminManager }，溯源属性名对应的类型
-    if (node.shorthand) {
-      return this._traceIdentifierType(node.key.name, node);
-    }
-    
-    // 对于完整属性 { Admin_DD: Admin }，溯源属性值对应的类型
-    if (!node.shorthand && node.value && node.value.type === 'Identifier') {
-      return this._traceIdentifierType(node.value.name, node);
-    }
-    
-    // 其他情况无法溯源
-    return null;
-  }
-
-  /**
-   * 溯源标识符的类型
-   * @param {string} name 标识符名
-   * @param {object} node AST节点
-   * @returns {string} 溯源到的类型，无法溯源则返回null
-   */
-  _traceIdentifierType(name, node) {
-    if (!name || !node) {
-      return null;
-    }
-    
-    // 获取Program节点（AST根节点）
-    var program_node = this._getProgramNode(node);
-    if (!program_node || !program_node.body) {
-      return null;
-    }
-    
-    // 遍历同级节点查找声明
-    for (var i = 0; i < program_node.body.length; i++) {
-      var sibling_node = program_node.body[i];
-      
-      // 查找类声明
-      if (sibling_node.type === 'ClassDeclaration') {
-        if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
-          return 'class';
-        }
-      }
-      
-      // 查找函数声明
-      if (sibling_node.type === 'FunctionDeclaration') {
-        if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
-          return 'function';
-        }
-      }
-      
-      // 查找变量声明
-      if (sibling_node.type === 'VariableDeclaration') {
-        for (var j = 0; j < sibling_node.declarations.length; j++) {
-          var decl = sibling_node.declarations[j];
-          if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
-            // 检查变量声明的类型
-            if (decl.init) {
-              // 类表达式
-              if (decl.init.type === 'ClassExpression') {
-                return 'class';
-              }
-              
-              // 函数表达式
-              if (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression') {
-                return 'function';
-              }
-              
-              // new 表达式（类实例）
-              if (decl.init.type === 'NewExpression') {
-                return 'class-instance';
-              }
-              
-              // 常量（只有const声明且为基础字面量）
-              if (sibling_node.kind === 'const' && this._isBasicLiteralValue(decl.init)) {
-                return 'constant';
-              }
-              
-              // 普通变量
-              return 'variable';
-            }
-            
-            // 没有初始值的变量声明，默认为变量
-            return 'variable';
-          }
-        }
-      }
-    }
-    
-    // 无法溯源到具体类型
-    return null;
-  }
-
-  /**
-   * 检查属性名是否在作用域内有对应的类声明
-   * @param {string} name 属性名
-   * @param {object} node AST节点
-   * @returns {boolean} 是否是类引用
-   */
-  _isClassReference(name, node) {
-    if (!name || !node) {
-      return false;
-    }
-    
-    console.log('  [DEBUG] _isClassReference called:', name);
-    
-    // 在ESLint环境中，AST节点有parent属性，可以向上遍历
-    // 获取Program节点（AST根节点）
-    var program_node = this._getProgramNode(node);
-    console.log('  [DEBUG] Program node:', program_node ? program_node.type : 'null');
-    
-    if (!program_node || !program_node.body) {
-      console.log('  [DEBUG] No program node or body');
-      return false;
-    }
-    
-    console.log('  [DEBUG] Program body length:', program_node.body.length);
-    
-    // 遍历同级节点查找类声明
-    for (var i = 0; i < program_node.body.length; i++) {
-      var sibling_node = program_node.body[i];
-      console.log('  [DEBUG] Sibling node', i, ':', sibling_node.type);
-      
-      // 查找类声明
-      if (sibling_node.type === 'ClassDeclaration') {
-        console.log('  [DEBUG] Found ClassDeclaration:', sibling_node.id ? sibling_node.id.name : 'null');
-        if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
-          console.log('  [DEBUG] Class reference found!');
-          return true;
-        }
-      }
-      
-      // 查找变量声明中的类表达式
-      if (sibling_node.type === 'VariableDeclaration') {
-        for (var j = 0; j < sibling_node.declarations.length; j++) {
-          var decl = sibling_node.declarations[j];
-          if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
-            // 检查是否为类表达式
-            if (decl.init && decl.init.type === 'ClassExpression') {
-              return true;
-            }
-          }
-        }
-      }
-    }
-    
-    console.log('  [DEBUG] No class reference found');
-    return false;
-  }
-
-  /**
-   * 获取Program节点（AST根节点）
-   * @param {object} node AST节点
-   * @returns {object} Program节点
-   */
-  _getProgramNode(node) {
-    var current_node = node;
-    
-    // 在ESLint环境中，AST节点有parent属性，可以向上遍历
-    // 向上遍历直到找到Program节点
-    while (current_node && current_node.parent) {
-      current_node = current_node.parent;
-      
-      // 如果找到Program节点，返回它
-      if (current_node.type === 'Program') {
-        return current_node;
-      }
-    }
-    
-    // 如果没有找到Program节点，返回null
-    return null;
-  }
-
-  /**
-   * 获取父级声明类型
-   * @param {object} node AST节点
-   * @returns {string} 声明类型
-   */
-  _getParentDeclarationType(node) {
-    var current_node = node;
-
-    while (current_node.parent) {
-      current_node = current_node.parent;
-
-      if (current_node.type === 'VariableDeclarator' && current_node.parent && current_node.parent.kind) {
-        return current_node.parent.kind;
-      }
-
-      if (current_node.type === 'AssignmentExpression') {
-        return 'variable';
-      }
-    }
-
-    return 'unknown';
-  }
-
-  /**
-   * 获取父级对象节点
-   * @param {object} node AST节点
-   * @returns {object|null} 父级对象节点
-   */
-  _getParentObject(node) {
-    var current_node = node;
-
-    while (current_node.parent) {
-      current_node = current_node.parent;
-
-      if (current_node.type === 'ObjectExpression') {
-        return current_node;
-      }
-
-      if (current_node.type === 'VariableDeclarator' || current_node.type === 'AssignmentExpression') {
-        break;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 判断是否为基础字面量值（排除正则表达式）
-   * @param {object} node AST节点
-   * @returns {boolean} 是否为基础字面量
-   */
-  _isBasicLiteralValue(node) {
-    if (!node) {
-      return false;
-    }
-
-    switch (node.type) {
-      case 'Literal':
-        // 排除正则表达式
-        return !node.regex;
-      case 'TemplateLiteral':
-        return true;
-      case 'ArrayExpression':
-        // 数组必须所有元素都是基础字面量
-        if (node.elements && node.elements.length > 0) {
-          for (var i = 0; i < node.elements.length; i++) {
-            if (!this._isBasicLiteralValue(node.elements[i])) {
-              return false;
-            }
-          }
-        }
-        return true;
-      case 'ObjectExpression':
-        // 对象必须所有属性值都是基础字面量
-        if (node.properties && node.properties.length > 0) {
-          for (var i = 0; i < node.properties.length; i++) {
-            var property = node.properties[i];
-            if (property.value && !this._isBasicLiteralValue(property.value)) {
-              return false;
-            }
-          }
-        }
-        return true;
-      case 'Identifier':
-        var basic_literal_identifiers = ['undefined', 'null', 'Infinity', 'NaN', 'true', 'false'];
-        return basic_literal_identifiers.includes(node.name);
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * 检查对象的所有属性是否都是字面量
-   * @param {object} object_node 对象节点
-   * @returns {boolean} 是否所有属性都是字面量
-   */
-  _isObjectAllLiteral(object_node) {
-    if (object_node.type !== 'ObjectExpression' || !object_node.properties) {
-      return false;
-    }
-
-    for (var i = 0; i < object_node.properties.length; i++) {
-      var property = object_node.properties[i];
-
-      // 跳过解构赋值
-      if (property.type !== 'Property') {
-        continue;
-      }
-
-      // 检查属性值是否为字面量
-      if (!this._isLiteralValue(property.value)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-}
-
-module.exports = { Detector };