mm_eslint 1.4.4 → 1.4.5

package/detector.js

@@ -1,1239 +1,1291 @@
-
-const { Config } = require('./config');
-const { Validator } = require('./validator');
-const { Corrector } = require('./corrector');
-const { Tip } = require('./tip');
-
-/**
- * 命名规范检测器类
- * 负责检测命名类型
- */
-class Detector {
-  /**
-   * 构造函数
-   * @param {object} config 配置对象
-   */
-  constructor(config) {
-    this.config = config || new Config();
-    this.validator = new Validator(config);
-    this.corrector = new Corrector(config);
-    this.tip = new Tip(config);
-  }
-}
-
-/**
- * 获取原始类型
- * @param {object} node AST节点
- * @returns {string} 原始类型
- */
-Detector.prototype._getOriginalType = function (node) {
-  if (!node) {
-    return 'variable';
-  }
-
-  // 检查是否为属性节点
-  var is_property = false;
-  var current_node = node;
-
-  // 特殊处理：类中的实例方法应该视为属性函数
-  var is_class_method = false;
-  var is_static_method = false;
-
-  if (node.type === 'MethodDefinition') {
-    is_class_method = true;
-    is_static_method = node.static || false;
-  }
-
-  while (current_node.parent) {
-    // 如果是属性节点或成员表达式，且不是顶层声明
-    if (current_node.parent.type === 'Property' ||
-      current_node.parent.type === 'MemberExpression') {
-      is_property = true;
-      break;
-    }
-    // 如果是对象表达式，但父级不是变量声明，则视为属性
-    if (current_node.parent.type === 'ObjectExpression' &&
-      current_node.parent.parent &&
-      current_node.parent.parent.type !== 'VariableDeclarator') {
-      is_property = true;
-      break;
-    }
-    // 类中的实例方法应该视为属性函数，但静态方法保持静态函数类型
-    if (current_node.parent.type === 'ClassBody' ||
-      current_node.parent.type === 'ClassDeclaration' ||
-      current_node.parent.type === 'ClassExpression') {
-      // 如果是类中的方法，但不是静态方法，则视为属性
-      if (is_class_method && !is_static_method) {
-        is_property = true;
-      }
-      break;
-    }
-    current_node = current_node.parent;
-  }
-
-  // 根据AST节点类型映射到配置文件中定义的命名类型
-  switch (node.type) {
-    case 'ClassDeclaration':
-    case 'ClassExpression':
-      return is_property ? 'property-class' : 'class';
-
-    case 'MethodDefinition':
-      // 检查是否是静态方法
-      if (node.static) {
-        return is_property ? 'property-static-function' : 'static-function';
-      }
-      // 私有方法使用与普通方法相同的命名规则
-      return is_property ? 'property-function' : 'function';
-
-    case 'FunctionDeclaration':
-    case 'FunctionExpression':
-    case 'ArrowFunctionExpression':
-      return is_property ? 'property-function' : 'function';
-
-    case 'VariableDeclarator':
-      return this._getVariableDeclaratorType(node);
-
-    case 'Property':
-      // 属性节点需要根据属性值类型进一步判断
-      return this._getPropertyType(node);
-
-    case 'NewExpression':
-      return is_property ? 'property-class-instance' : 'class-instance';
-
-    case 'AssignmentExpression':
-      // 赋值表达式：根据赋值右侧的类型判断
-      return this._getAssignmentPropertyType(node);
-
-    case 'PropertyDefinition':
-      // 类属性：根据属性值的类型判断
-      if (node.value && node.value.type === 'NewExpression') {
-        // 如果是new表达式，则根据是否为静态属性判断类型
-        if (node.static) {
-          return 'static-class-instance';  // 静态类字段实例
-        }
-        return 'property-class-instance';  // 普通类字段实例
-      }
-      
-      // 检查是否为函数类型的属性值
-      if (node.value) {
-        var function_types = ['FunctionExpression', 'ArrowFunctionExpression'];
-        if (function_types.includes(node.value.type)) {
-          // 类属性函数：根据是否为静态属性判断类型
-          if (node.static) {
-            return 'static-function';  // 静态类字段函数
-          }
-          return 'property-function';  // 普通类字段函数
-        }
-      }
-      
-      // 类属性：根据是否为静态属性判断类型
-      if (node.static) {
-        return 'static-variable';
-      }
-      return 'property-variable';
-
-    case 'Identifier':
-      // 如果是属性名标识符
-      if (node.parent && node.parent.type === 'Property' && node.parent.key === node) {
-        // 根据属性值的类型判断属性类型
-        return this._getPropertyType(node.parent);
-      }
-
-      // 如果是赋值表达式中的属性名标识符
-      if (node.parent && node.parent.type === 'MemberExpression' &&
-        node.parent.property === node && node.parent.parent &&
-        node.parent.parent.type === 'AssignmentExpression') {
-        // 根据赋值右侧的类型判断属性类型
-        return this._getAssignmentPropertyType(node.parent.parent);
-      }
-
-      // 如果是类名标识符
-      if (node.parent && (node.parent.type === 'ClassDeclaration' ||
-        node.parent.type === 'ClassExpression')) {
-        return is_property ? 'property-class' : 'class';
-      }
-
-      // 如果是变量声明标识符
-      if (node.parent && node.parent.type === 'VariableDeclarator' &&
-        node.parent.id === node) {
-        return this._getVariableDeclaratorType(node.parent, is_property);
-      }
-
-      // 如果是参数节点（函数声明、函数表达式中的参数）
-      if (node.parent && (node.parent.type === 'FunctionDeclaration' ||
-        node.parent.type === 'FunctionExpression' ||
-        node.parent.type === 'ArrowFunctionExpression')) {
-        // 检查是否是函数参数（不是函数名）
-        if (node.parent.params && node.parent.params.includes(node)) {
-          return 'param';
-        }
-        // 如果不是参数，则是函数名
-        return is_property ? 'property-function' : 'function';
-      }
-
-      // 如果是函数调用中的函数名标识符
-      if (node.parent && node.parent.type === 'CallExpression' &&
-        node.parent.callee === node) {
-        return is_property ? 'property-function' : 'function';
-      }
-
-      // 如果是方法参数节点
-      if (node.parent && node.parent.type === 'MethodDefinition') {
-        // 检查是否是方法参数（不是方法名）
-        if (node.parent.value && node.parent.value.params && node.parent.value.params.includes(node)) {
-          return 'param';
-        }
-      }
-
-      // 其他标识符根据上下文判断
-      return is_property ? 'property-variable' : 'variable';
-
-    default:
-      return is_property ? 'property-variable' : 'variable';
-  }
-};
-
-/**
- * 检测命名规范
- * @param {string} name 名称
- * @param {object} node AST节点
- * @param {string} expected_type 期望的命名类型
- * @returns {object} 检测结果
- */
-Detector.prototype.detect = function (name, node, expected_type = null) {
-  // 根据AST节点类型自动推断命名类型
-  var original_type = this._getOriginalType(node);
-  
-  // 如果指定了期望类型，但推断类型不匹配，则返回null
-  if (expected_type && original_type !== expected_type) {
-    return null;
-  }
-  
-  var error = this.validator.validate(name, original_type);
-  if (!error) {
-    return null;
-  }
-  var fix_suggestion = this.corrector.getSuggestion(error);
-  var message = this.tip.getFullMessage(error, fix_suggestion);
-  return {
-    node,
-    message,
-    error_type: error.type,
-    severity: error.severity,
-    fix_suggestion: fix_suggestion,
-    original_type: original_type
-  }
-}
-
-/**
- * 获取变量声明类型
- * @param {object} node 变量声明节点
- * @param {boolean} is_property 是否为属性节点
- * @returns {string} 原始类型
- */
-Detector.prototype._getVariableDeclaratorType = function (node, is_property = false) {
-  // 检查是否为类表达式赋值
-  if (node.init && node.init.type === 'ClassExpression') {
-    return is_property ? 'property-class' : 'class'; // 类表达式赋值 -> 类类型
-  }
-
-  // 检查是否为函数赋值
-  if (node.init && (node.init.type === 'FunctionExpression' ||
-    node.init.type === 'ArrowFunctionExpression')) {
-    // 特殊处理：检查是否为混入类（返回类表达式的箭头函数）
-    if (node.init.type === 'ArrowFunctionExpression' && 
-        node.init.body && node.init.body.type === 'ClassExpression') {
-      return is_property ? 'property-class' : 'class'; // 混入类 -> 类类型
-    }
-    return is_property ? 'property-function' : 'function'; // 函数赋值 -> 函数类型
-  }
-
-  // 检查是否为类实例赋值
-  if (node.init && node.init.type === 'NewExpression') {
-    return is_property ? 'property-class-instance' : 'class-instance'; // 类实例赋值 -> 类实例类型
-  }
-
-  // 检查是否为正则表达式字面量（RegExp实例）
-  if (node.init && node.init.type === 'Literal' && node.init.regex) {
-    return is_property ? 'property-class-instance' : 'class-instance'; // 正则表达式字面量 -> 类实例类型
-  }
-
-  // 检查是否为包含函数的对象（类实例）
-  if (node.init && node.init.type === 'ObjectExpression' &&
-    node.init.properties && node.init.properties.length > 0) {
-    for (var i = 0; i < node.init.properties.length; i++) {
-      var property = node.init.properties[i];
-      if (property.value && (property.value.type === 'FunctionExpression' ||
-        property.value.type === 'ArrowFunctionExpression' ||
-        property.value.type === 'ClassExpression')) {
-        return is_property ? 'property-class-instance' : 'class-instance'; // 包含函数的对象 -> 类实例
-      }
-    }
-  }
-
-  // 检查是否为字面量赋值
-  if (node.init && this._isLiteralValue(node.init)) {
-    // 只有纯字面量才能被识别为变量或常量
-    if (node.parent && node.parent.kind === 'const') {
-      return is_property ? 'property-constant' : 'constant'; // const 声明的字面量 -> 常量
-    }
-    return is_property ? 'property-variable' : 'variable'; // let/var 声明的字面量 -> 变量
-  }
-
-  // 检查是否为函数调用赋值
-  if (node.init && node.init.type === 'CallExpression') {
-    // 特殊处理：检查是否为Object.freeze/Object.seal调用
-    var callee = node.init.callee;
-    if (callee.type === 'MemberExpression') {
-      var object_name = callee.object.name;
-      var property_name = callee.property.name;
-      if (object_name === 'Object' &&
-        (property_name === 'freeze' || property_name === 'seal')) {
-        // Object.freeze/Object.seal包装的字面量应该视为常量
-        if (node.parent && node.parent.kind === 'const') {
-          return is_property ? 'property-constant' : 'constant';
-        }
-      }
-    }
-    // 其他函数调用赋值应该视为变量
-    return is_property ? 'property-variable' : 'variable';
-  }
-
-  // 检查是否为标识符赋值（如 undefined、null 等）
-  if (node.init && node.init.type === 'Identifier') {
-    // 特殊标识符赋值应该视为变量
-    var identifier_name = node.init.name;
-    if (identifier_name === 'undefined' || identifier_name === 'null' || identifier_name === 'NaN' || identifier_name === 'Infinity') {
-      return is_property ? 'property-variable' : 'variable';
-    }
-    // 其他标识符赋值视为类实例
-    return is_property ? 'property-class-instance' : 'class-instance';
-  }
-
-  // 其他非字面量赋值视为类实例
-  return is_property ? 'property-class-instance' : 'class-instance';
-};
-
-/**
- * 获取赋值表达式中的属性类型
- * @param {object} node 赋值表达式节点
- * @returns {string} 原始类型
- */
-Detector.prototype._getAssignmentPropertyType = function (node) {
-  if (!node.right) {
-    return 'property-variable';
-  }
-
-  // 根据赋值右侧的类型判断属性类型
-  switch (node.right.type) {
-    case 'FunctionExpression':
-    case 'ArrowFunctionExpression':
-      // 检查是否为原型方法赋值
-      if (node.left &&
-        node.left.type === 'MemberExpression' &&
-        node.left.object &&
-        node.left.object.type === 'MemberExpression' &&
-        node.left.object.property &&
-        node.left.object.property.type === 'Identifier' &&
-        node.left.object.property.name === 'prototype') {
-        return 'prototype-function';
-      }
-      return 'property-function';
-
-    case 'ClassExpression':
-      return 'property-class';
-
-    case 'NewExpression':
-      return 'property-class-instance';
-
-    case 'CallExpression':
-      // 函数调用：根据函数名推断返回值类型
-      // 如果函数名以'create'、'get'、'make'等开头，可能返回实例
-      if (node.right.callee && node.right.callee.type === 'Identifier') {
-        var func_name = node.right.callee.name.toLowerCase();
-        if (func_name.startsWith('create') || func_name.startsWith('get') ||
-          func_name.startsWith('make') || func_name.startsWith('build')) {
-          return 'property-class-instance';
-        }
-      }
-      return 'property-variable';
-
-    case 'Literal':
-    case 'TemplateLiteral':
-    case 'ArrayExpression':
-    case 'ObjectExpression':
-      // 字面量值：根据属性名判断类型
-      if (node.left && node.left.type === 'MemberExpression' && 
-          node.left.property && node.left.property.type === 'Identifier') {
-        var property_name = node.left.property.name;
-        
-        // 检查属性名是否为常量名规范（UPPER_SNAKE_CASE）
-        var constant_name_regex = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
-        if (constant_name_regex.test(property_name)) {
-          return 'property-constant';
-        }
-        
-        // 检查属性名是否为类名规范（PascalCase）
-        var class_name_regex = /^[A-Z][a-z]*([A-Z][a-z]*)*$/;
-        if (class_name_regex.test(property_name)) {
-          return 'property-class';
-        }
-      }
-      return 'property-variable';
-
-    case 'Identifier':
-      // 检查标识符是否为类引用
-      // 如果标识符名称符合类名规范（PascalCase），则视为类引用
-      var class_name_regex = /^[A-Z][a-z]*([A-Z][a-z]*)*$/;
-
-      // 检查标识符是否为常量引用
-      // 如果标识符名称符合常量名规范（UPPER_SNAKE_CASE），则视为常量引用
-      var constant_name_regex = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
-
-      // 检查是否为解构赋值的情况（node.right可能不存在）
-      if (node.right && node.right.name) {
-        if (class_name_regex.test(node.right.name)) {
-          return 'property-class';
-        }
-        if (constant_name_regex.test(node.right.name)) {
-          return 'property-constant';
-        }
-      }
-
-      // 对于解构赋值中的标识符，直接根据标识符名称判断
-      if (node.value && node.value.name) {
-        if (class_name_regex.test(node.value.name)) {
-          return 'property-class';
-        }
-        if (constant_name_regex.test(node.value.name)) {
-          return 'property-constant';
-        }
-      }
-
-      return 'property-variable';
-
-    case 'Literal':
-    case 'TemplateLiteral':
-    case 'ArrayExpression':
-    case 'ObjectExpression':
-      // 检查是否为字面量值，并根据父级对象类型判断属性类型
-      if (this._isLiteralValue(node.value)) {
-        // 首先获取属性所在对象的类型
-        var parent_object_type = this._getParentObjectType(node);
-
-        // 如果父级对象是类实例，字面量属性值应该识别为变量属性
-        if (parent_object_type === 'class-instance' || parent_object_type === 'property-class-instance') {
-          return 'property-variable';
-        }
-
-        // 如果父级对象是常量，字面量属性值应该识别为常量属性
-        if (parent_object_type === 'constant' || parent_object_type === 'property-constant') {
-          return 'property-constant';
-        }
-
-        // 其他情况都视为变量属性
-        return 'property-variable';
-      }
-      return 'property-variable';
-
-    default:
-      return 'property-variable';
-  }
-};
-
-/**
- * 获取属性所在对象的类型
- * @param {object} node 属性节点
- * @returns {string} 对象类型
- */
-Detector.prototype._getParentObjectType = function (node) {
-  var current_node = node;
-
-  // 向上遍历父节点，找到对象表达式或变量声明
-  while (current_node.parent) {
-    current_node = current_node.parent;
-
-    // 如果是对象表达式，继续向上找变量声明
-    if (current_node.type === 'ObjectExpression') {
-      continue;
-    }
-
-    // 如果是变量声明，获取其类型
-    if (current_node.type === 'VariableDeclarator') {
-      return this._getVariableDeclaratorType(current_node, true); // true 表示是属性
-    }
-
-    // 如果是赋值表达式，获取其类型
-    if (current_node.type === 'AssignmentExpression') {
-      return this._getAssignmentPropertyType(current_node);
-    }
-  }
-
-  return 'unknown';
-};
-
-/**
- * 获取属性所在对象的声明类型
- * @param {object} node 属性节点
- * @returns {string} 声明类型（'const'、'let'、'var' 或 'unknown'）
- */
-Detector.prototype._getParentDeclarationType = function (node) {
-  var current_node = node;
-
-  // 向上遍历父节点，找到变量声明或赋值表达式
-  while (current_node.parent) {
-    current_node = current_node.parent;
-
-    // 如果是变量声明
-    if (current_node.type === 'VariableDeclarator') {
-      if (current_node.parent && current_node.parent.kind) {
-        return current_node.parent.kind; // 'const', 'let', 'var'
-      }
-    }
-
-    // 如果是赋值表达式
-    if (current_node.type === 'AssignmentExpression') {
-      return 'variable'; // 赋值表达式视为变量
-    }
-
-    // 如果是函数参数
-    if (current_node.type === 'FunctionDeclaration' ||
-      current_node.type === 'FunctionExpression' ||
-      current_node.type === 'ArrowFunctionExpression') {
-      return 'param'; // 函数参数
-    }
-  }
-
-  return 'unknown';
-};
-
-/**
- * 获取属性类型
- * @param {object} node 属性节点
- * @returns {string} 原始类型
- */
-Detector.prototype._getPropertyType = function (node) {
-  if (!node.value) {
-    return 'property-variable';
-  }
-
-  // 根据属性值的类型判断属性类型
-  switch (node.value.type) {
-    case 'FunctionExpression':
-    case 'ArrowFunctionExpression':
-      return 'property-function';
-
-    case 'ClassExpression':
-      return 'property-class';
-
-    case 'NewExpression':
-      return 'property-class-instance';
-
-    case 'Identifier':
-      // 检查标识符是否为类引用
-      // 如果标识符名称符合类名规范（PascalCase），则视为类引用
-      var class_name_regex = /^[A-Z][a-z]*([A-Z][a-z]*)*$/;
-
-      // 检查是否为解构赋值的情况（node.right可能不存在）
-      if (node.right && node.right.name && class_name_regex.test(node.right.name)) {
-        return 'property-class';
-      }
-
-      // 对于解构赋值中的标识符，直接根据标识符名称判断
-      if (node.value.name && class_name_regex.test(node.value.name)) {
-        return 'property-class';
-      }
-
-      // 检查标识符是否为函数参数引用
-      if (this._isParameterName(node.value)) {
-        return 'property-variable'; // 函数参数引用应该视为变量属性
-      }
-
-      return 'property-variable';
-
-    case 'Literal':
-    case 'TemplateLiteral':
-    case 'ArrayExpression':
-    case 'ObjectExpression':
-      // 检查是否为字面量值，并根据属性名判断类型
-      if (this._isLiteralValue(node.value)) {
-        // 首先根据属性名判断类型
-        if (node.key && node.key.type === 'Identifier') {
-          var property_name = node.key.name;
-          
-          // 检查属性名是否为常量名规范（UPPER_SNAKE_CASE）
-          var constant_name_regex = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
-          if (constant_name_regex.test(property_name)) {
-            return 'property-constant';
-          }
-          
-          // 检查属性名是否为类名规范（PascalCase）
-          var class_name_regex = /^[A-Z][a-z]*([A-Z][a-z]*)*$/;
-          if (class_name_regex.test(property_name)) {
-            return 'property-class';
-          }
-        }
-        
-        // 如果属性名不符合特定规范，再根据父级对象类型判断
-        var parent_object_type = this._getParentObjectType(node);
-
-        // 如果父级对象是类实例，字面量属性值应该识别为变量属性
-        if (parent_object_type === 'class-instance' || parent_object_type === 'property-class-instance') {
-          return 'property-variable';
-        }
-
-        // 如果父级对象是常量，字面量属性值应该识别为常量属性
-        if (parent_object_type === 'constant' || parent_object_type === 'property-constant') {
-          return 'property-constant';
-        }
-
-        // 其他情况都视为变量属性
-        return 'property-variable';
-      }
-      return 'property-variable';
-
-    default:
-      return 'property-variable';
-  }
-};
-
-/**
- * 判断是否为字面量值
- * @param {object} node AST节点
- * @returns {boolean} 是否为字面量
- */
-Detector.prototype._isLiteralValue = function (node) {
-  if (!node) {
-    return false;
-  }
-
-  switch (node.type) {
-    case 'Literal':
-      // 布尔型、字符串型、数字型字面量
-      // 排除正则表达式字面量（应该视为类实例）
-      if (node.regex) {
-        // 正则表达式字面量有regex属性，应该视为类实例，不是普通字面量
-        return false;
-      }
-      return true;
-
-    case 'TemplateLiteral':
-      // 模板字符串字面量
-      return true;
-
-    case 'Identifier':
-      // 特殊字面量标识符：undefined、null、Infinity、NaN等
-      var literal_identifiers = ['undefined', 'null', 'Infinity', 'NaN', 'true', 'false'];
-      if (literal_identifiers.includes(node.name)) {
-        return true;
-      }
-      return false;
-
-    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;
-      }
-      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;
-      }
-      return true; // 空对象也是字面量
-
-    default:
-      return false;
-  }
-};
-
-/**
- * 检查节点是否为参数名或参数引用
- * @param {object} node AST节点
- * @returns {boolean} 是否为参数名或参数引用
- */
-Detector.prototype._isParameterName = function (node) {
-  if (!node || !node.parent) {
-    return false;
-  }
-
-  // 检查是否为函数参数声明
-  var parent = node.parent;
-  if (parent.type === 'FunctionDeclaration' ||
-    parent.type === 'FunctionExpression' ||
-    parent.type === 'ArrowFunctionExpression') {
-    if (parent.params && Array.isArray(parent.params)) {
-      for (var i = 0; i < parent.params.length; i++) {
-        if (parent.params[i] === node) {
-          return true;
-        }
-      }
-    }
-  }
-
-  // 检查是否为函数参数引用（在函数体中使用参数）
-  var current_node = node;
-  while (current_node.parent) {
-    // 检查是否在函数体内
-    if (current_node.parent.type === 'FunctionDeclaration' ||
-        current_node.parent.type === 'FunctionExpression' ||
-        current_node.parent.type === 'ArrowFunctionExpression') {
-      
-      // 检查标识符名称是否与函数参数匹配
-      var function_node = current_node.parent;
-      if (function_node.params && Array.isArray(function_node.params)) {
-        for (var i = 0; i < function_node.params.length; i++) {
-          var param = function_node.params[i];
-          // 对于普通参数
-          if (param.type === 'Identifier' && param.name === node.name) {
-            return true;
-          }
-          // 对于解构参数，需要递归检查
-          if ((param.type === 'ObjectPattern' || param.type === 'ArrayPattern') && 
-              this._isParameterInDestructuredPattern(param, node.name)) {
-            return true;
-          }
-        }
-      }
-      break;
-    }
-    current_node = current_node.parent;
-  }
-
-  return false;
-}
-
-/**
- * 检查是否为真正的常量（const标签且值为字面量）
- * @param {string} constant_name 常量名
- * @param {object} decl 声明节点
- * @returns {boolean} 是否为真正的常量
- */
-Detector.prototype._isTrueConstant = function (constant_name, decl) {
-  // 检查是否为字面量值
-  var is_literal = false;
-  if (decl.init) {
-    // 基本字面量类型
-    var literal_types = ['Literal', 'RegExpLiteral', 'TemplateLiteral'];
-    if (literal_types.includes(decl.init.type)) {
-      is_literal = true;
-    }
-
-    // 函数类型不是字面量，应该被识别为函数而不是常量
-    var function_types = ['FunctionExpression', 'ArrowFunctionExpression'];
-    if (function_types.includes(decl.init.type)) {
-      return false; // 函数赋值不是字面量，不是真正的常量
-    }
-
-    // 对象字面量 - 只有当所有属性值都是字面量时才视为常量
-    if (decl.init.type === 'ObjectExpression') {
-      var all_properties_literal = true;
-      if (decl.init.properties && decl.init.properties.length > 0) {
-        decl.init.properties.forEach(function (prop) {
-          if (prop.value) {
-            // 检查属性值是否为非字面量类型
-            var non_literal_types = ['NewExpression', 'CallExpression', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassExpression'];
-            if (non_literal_types.includes(prop.value.type)) {
-              all_properties_literal = false;
-            }
-            // 如果属性值是对象或数组，递归检查
-            else if (prop.value.type === 'ObjectExpression' || prop.value.type === 'ArrayExpression') {
-              // 创建一个假的声明节点来递归检查
-              var fake_decl = { init: prop.value };
-              if (!_isTrueConstant('', fake_decl)) {
-                all_properties_literal = false;
-              }
-            }
-          }
-        });
-      }
-      is_literal = all_properties_literal;
-    }
-
-    // 数组字面量 - 只有当所有元素都是字面量时才视为常量
-    if (decl.init.type === 'ArrayExpression') {
-      var all_elements_literal = true;
-      if (decl.init.elements && decl.init.elements.length > 0) {
-        decl.init.elements.forEach(function (element) {
-          if (element) {
-            // 检查元素是否为非字面量类型
-            var non_literal_types = ['NewExpression', 'CallExpression', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassExpression', 'AssignmentExpression'];
-            if (non_literal_types.includes(element.type)) {
-              all_elements_literal = false;
-            }
-            // 如果元素是对象或数组，递归检查
-            else if (element.type === 'ObjectExpression' || element.type === 'ArrayExpression') {
-              // 创建一个假的声明节点来递归检查
-              var fake_decl = { init: element };
-              if (!_isTrueConstant('', fake_decl)) {
-                all_elements_literal = false;
-              }
-            }
-          }
-        });
-      }
-      is_literal = all_elements_literal;
-    }
-
-    // Object.freeze/Object.seal包装的字面量
-    if (decl.init.type === 'CallExpression') {
-      var callee = decl.init.callee;
-      if (callee.type === 'MemberExpression') {
-        var object_name = callee.object.name;
-        var property_name = callee.property.name;
-        if (object_name === 'Object' &&
-          (property_name === 'freeze' || property_name === 'seal')) {
-          // 检查第一个参数是否为字面量
-          var args = decl.init.arguments;
-          if (args && args.length > 0) {
-            var first_arg = args[0];
-            if (first_arg.type === 'ObjectExpression' ||
-              first_arg.type === 'ArrayExpression') {
-              // 创建一个假的声明节点来检查参数是否为字面量
-              var fake_decl = { init: first_arg };
-              is_literal = _isTrueConstant('', fake_decl);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // 真正的常量是const声明且值为字面量
-  return is_literal;
-}
-
-/**
- * 获取变量验证类型
- * @param {object} node 变量声明节点
- * @returns {string} 验证类型
- */
-Detector.prototype._getVariableValidationType = function (node) {
-  // 检查是否为常量声明
-  if (node.parent && node.parent.kind === 'const') {
-    // 检查是否为字面量赋值
-    if (node.init && this._isLiteralValue(node.init)) {
-      return 'constant';
-    }
-    return 'variable'; // const 声明的非字面量视为变量
-  }
-
-  // 检查是否为参数
-  if (node.parent && (node.parent.type === 'FunctionDeclaration' ||
-    node.parent.type === 'FunctionExpression' ||
-    node.parent.type === 'ArrowFunctionExpression')) {
-    return 'param';
-  }
-
-  return 'variable';
-};
-
-/**
- * 获取赋值验证类型
- * @param {object} node 赋值表达式节点
- * @returns {string} 验证类型
- */
-Detector.prototype._getAssignmentValidationType = function (node) {
-  // 检查是否为类实例赋值
-  if (node.right && node.right.type === 'NewExpression') {
-    return 'class-instance'; // 类实例使用类实例命名规则
-  }
-
-  // 检查是否为函数赋值
-  if (node.right && (node.right.type === 'FunctionExpression' ||
-    node.right.type === 'ArrowFunctionExpression')) {
-    return 'function';
-  }
-
-  return 'variable';
-};
-
-/**
- * 获取导出验证类型
- * @param {object} node 导出声明节点
- * @returns {string} 验证类型
- */
-Detector.prototype._getExportValidationType = function (node) {
-  // 根据导出内容的类型决定验证类型
-  if (node.declaration) {
-    switch (node.declaration.type) {
-      case 'ClassDeclaration':
-      case 'ClassExpression':
-        return 'class';
-
-      case 'FunctionDeclaration':
-      case 'FunctionExpression':
-        return 'function';
-
-      case 'VariableDeclaration':
-        // 检查是否为常量导出
-        if (node.declaration.kind === 'const') {
-          return 'constant';
-        }
-        return 'variable';
-
-      default:
-        return 'variable';
-    }
-  }
-
-  return 'variable';
-};
-
-/**
- * 获取默认导出验证类型
- * @param {object} node 默认导出节点
- * @returns {string} 验证类型
- */
-Detector.prototype._getExportDefaultValidationType = function (node) {
-  // 根据默认导出内容的类型决定验证类型
-  if (node.declaration) {
-    switch (node.declaration.type) {
-      case 'ClassDeclaration':
-      case 'ClassExpression':
-        return 'class';
-
-      case 'FunctionDeclaration':
-      case 'FunctionExpression':
-        return 'function';
-
-      default:
-        return 'class'; // 默认导出通常使用类名规则
-    }
-  }
-
-  return 'class'; // 默认使用类名规则
-};
-
-/**
- * 获取导入验证类型
- * @param {object} node 导入节点
- * @returns {string} 验证类型
- */
-Detector.prototype._getImportValidationType = function (node) {
-  // 根据导入内容的类型决定验证类型
-
-  // 默认导入通常导入类或默认导出
-  if (node.type === 'ImportDefaultSpecifier') {
-    return 'class';
-  }
-
-  // 命名空间导入使用变量名规则
-  if (node.type === 'ImportNamespaceSpecifier') {
-    return 'variable';
-  }
-
-  // 命名导入根据导入名称推断类型
-  if (node.type === 'ImportSpecifier') {
-    var imported_name = node.imported ? node.imported.name : '';
-
-    // 如果导入的名称以大写字母开头，可能是类
-    if (/^[A-Z]/.test(imported_name)) {
-      return 'class';
-    }
-
-    // 如果导入的名称包含特定关键词，可能是函数
-    var function_keywords = ['get', 'set', 'is', 'has', 'on', 'handle', 'callback'];
-    var lower_name = imported_name.toLowerCase();
-    for (var i = 0; i < function_keywords.length; i++) {
-      if (lower_name.includes(function_keywords[i])) {
-        return 'function';
-      }
-    }
-
-    // 如果导入的名称全大写，可能是常量
-    if (imported_name === imported_name.toUpperCase()) {
-      return 'constant';
-    }
-  }
-
-  // 默认使用变量名规则
-  return 'variable';
-};
-
-/**
- * 检测参数类型并返回正确的验证类型
- * @param {string} name 参数名
- * @param {object} node 参数节点
- * @returns {string} 验证类型
- */
-Detector.prototype._getParamValidationType = function (name, node) {
-  // 根据参数名推断参数类型
-  // 1. 如果参数名以大写字母开头，可能是类类型参数
-  if (/^[A-Z]/.test(name)) {
-    return 'class';
-  }
-
-  // 2. 如果参数名包含'on'、'handle'、'callback'等，可能是函数类型参数
-  var function_keywords = ['on', 'handle', 'callback', 'func', 'fn', 'cb'];
-  var lower_name = name.toLowerCase();
-  for (var i = 0; i < function_keywords.length; i++) {
-    if (lower_name.includes(function_keywords[i])) {
-      return 'function';
-    }
-  }
-
-  // 3. 默认使用变量类型参数规则
-  return 'variable';
-};
-
-/**
- * 检查是否为真正的常量（const标签且值为字面量）
- * @param {string} constant_name 常量名
- * @param {object} decl 声明节点
- * @returns {boolean} 是否为真正的常量
- */
-Detector.prototype._isTrueConstant = function (constant_name, decl) {
-  // 检查是否为字面量值
-  var is_literal = false;
-  if (decl.init) {
-    // 基本字面量类型
-    var literal_types = ['Literal', 'RegExpLiteral', 'TemplateLiteral'];
-    if (literal_types.includes(decl.init.type)) {
-      is_literal = true;
-    }
-
-    // 函数类型不是字面量，应该被识别为函数而不是常量
-    var function_types = ['FunctionExpression', 'ArrowFunctionExpression'];
-    if (function_types.includes(decl.init.type)) {
-      return false; // 函数赋值不是字面量，不是真正的常量
-    }
-
-    // 对象字面量 - 只有当所有属性值都是字面量时才视为常量
-    if (decl.init.type === 'ObjectExpression') {
-      var all_properties_literal = true;
-      if (decl.init.properties && decl.init.properties.length > 0) {
-        decl.init.properties.forEach(function (prop) {
-          if (prop.value) {
-            // 检查属性值是否为非字面量类型
-            var non_literal_types = ['NewExpression', 'CallExpression', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassExpression'];
-            if (non_literal_types.includes(prop.value.type)) {
-              all_properties_literal = false;
-            }
-            // 如果属性值是对象或数组，递归检查
-            else if (prop.value.type === 'ObjectExpression' || prop.value.type === 'ArrayExpression') {
-              // 创建一个假的声明节点来递归检查
-              var fake_decl = { init: prop.value };
-              if (!this._isLiteralValue(prop.value)) {
-                all_properties_literal = false;
-              }
-            }
-          }
-        }.bind(this));
-      }
-      is_literal = all_properties_literal;
-    }
-
-    // 数组字面量 - 只有当所有元素都是字面量时才视为常量
-    if (decl.init.type === 'ArrayExpression') {
-      var all_elements_literal = true;
-      if (decl.init.elements && decl.init.elements.length > 0) {
-        decl.init.elements.forEach(function (element) {
-          if (element) {
-            // 检查元素是否为非字面量类型
-            var non_literal_types = ['NewExpression', 'CallExpression', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassExpression', 'AssignmentExpression'];
-            if (non_literal_types.includes(element.type)) {
-              all_elements_literal = false;
-            }
-            // 如果元素是对象或数组，递归检查
-            else if (element.type === 'ObjectExpression' || element.type === 'ArrayExpression') {
-              // 检查元素是否为字面量
-              if (!this._isLiteralValue(element)) {
-                all_elements_literal = false;
-              }
-            }
-          }
-        }.bind(this));
-      }
-      is_literal = all_elements_literal;
-    }
-
-    // Object.freeze/Object.seal包装的字面量
-    if (decl.init.type === 'CallExpression') {
-      var callee = decl.init.callee;
-      if (callee.type === 'MemberExpression') {
-        var object_name = callee.object.name;
-        var property_name = callee.property.name;
-        if (object_name === 'Object' &&
-          (property_name === 'freeze' || property_name === 'seal')) {
-          // 检查第一个参数是否为字面量
-          var args = decl.init.arguments;
-          if (args && args.length > 0) {
-            var first_arg = args[0];
-            if (first_arg.type === 'ObjectExpression' ||
-              first_arg.type === 'ArrayExpression') {
-              // 检查参数是否为字面量
-              is_literal = this._isLiteralValue(first_arg);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // 真正的常量是const声明且值为字面量
-  return is_literal;
-};
-
-
-
-
-
-/**
- * 检查变量是否为类实例
- * @param {object} decl 变量声明节点
- * @returns {boolean} 是否为类实例
- */
-Detector.prototype._isClassInstance = function (decl) {
-  if (!decl.id || decl.id.type !== 'Identifier') {
-    return false;
-  }
-
-  // 检查变量是否被赋值为类实例（new ClassName()）
-  if (decl.init && decl.init.type === 'NewExpression') {
-    return true;
-  }
-
-  // 检查变量是否被赋值为函数返回的类实例
-  if (decl.init && decl.init.type === 'CallExpression') {
-    var callee = decl.init.callee;
-
-    // 检查是否为成员表达式调用（如 Math.random()）
-    if (callee.type === 'MemberExpression') {
-      var object_name = callee.object.name;
-      var property_name = callee.property.name;
-
-      // 排除常见的内置对象方法调用
-      if (object_name === 'Math' || object_name === 'Date' ||
-        object_name === 'String' || object_name === 'Number' ||
-        object_name === 'Array' || object_name === 'Object') {
-        return false;
-      }
-    }
-
-    // 检查是否为标识符调用
-    if (callee.type === 'Identifier') {
-      // 排除内置的数学函数
-      if (callee.name === 'random' || callee.name === 'now' ||
-        callee.name === 'floor' || callee.name === 'ceil' ||
-        callee.name === 'round' || callee.name === 'abs') {
-        return false;
-      }
-
-      // 排除常见的内置函数
-      var non_instance_functions = ['parseInt', 'parseFloat', 'encodeURI', 'decodeURI',
-        'encodeURIComponent', 'decodeURIComponent', 'isNaN',
-        'isFinite', 'eval', 'setTimeout', 'setInterval'];
-      if (non_instance_functions.includes(callee.name)) {
-        return false;
-      }
-
-      // 如果函数名包含create、get、build等关键词，可能是返回类实例的函数
-      if (callee.name.match(/^(create|get|build|make|new|init)/i)) {
-        return true;
-      }
-    }
-
-    // 默认情况下，函数调用不视为类实例
-    return false;
-  }
-
-  // 检查是否为内置类的实例（RegExp字面量、Array字面量等）
-  if (decl.init) {
-    // RegExp字面量 - 视为类实例
-    if (decl.init.type === 'Literal' && decl.init.regex) {
-      return true;
-    }
-    // Array字面量 [] - 只有当所有元素都是字面量时才视为变量
-    if (decl.init.type === 'ArrayExpression') {
-      return !this._isLiteralValue(decl.init);
-    }
-    // Object字面量 {} - 检查是否包含函数（类实例）
-    if (decl.init.type === 'ObjectExpression') {
-      // 如果对象包含函数，则视为类实例
-      if (decl.init.properties && decl.init.properties.length > 0) {
-        for (var i = 0; i < decl.init.properties.length; i++) {
-          var property = decl.init.properties[i];
-          if (property.value && (property.value.type === 'FunctionExpression' ||
-            property.value.type === 'ArrowFunctionExpression' ||
-            property.value.type === 'ClassExpression')) {
-            return true; // 包含函数的对象 -> 类实例
-          }
-        }
-      }
-      return false; // 纯字面量对象不是类实例
-    }
-    // 模板字面量 - 视为变量（基础值字符串类型）
-    if (decl.init.type === 'TemplateLiteral') {
-      return false;
-    }
-  }
-
-  return false;
-};
-
-/**
- * 检查标识符是否在解构参数模式中
- * @param {object} pattern 解构模式节点
- * @param {string} identifier_name 标识符名称
- * @returns {boolean} 是否在解构参数中
- */
-Detector.prototype._isParameterInDestructuredPattern = function (pattern, identifier_name) {
-  if (!pattern) {
-    return false;
-  }
-
-  // 处理对象解构模式
-  if (pattern.type === 'ObjectPattern' && pattern.properties) {
-    for (var i = 0; i < pattern.properties.length; i++) {
-      var property = pattern.properties[i];
-      // 检查属性键名是否匹配
-      if (property.key && property.key.type === 'Identifier' && property.key.name === identifier_name) {
-        return true;
-      }
-      // 检查属性值是否匹配（对于别名解构）
-      if (property.value && property.value.type === 'Identifier' && property.value.name === identifier_name) {
-        return true;
-      }
-      // 递归检查嵌套解构
-      if (property.value && (property.value.type === 'ObjectPattern' || property.value.type === 'ArrayPattern')) {
-        if (this._isParameterInDestructuredPattern(property.value, identifier_name)) {
-          return true;
-        }
-      }
-    }
-  }
-
-  // 处理数组解构模式
-  if (pattern.type === 'ArrayPattern' && pattern.elements) {
-    for (var i = 0; i < pattern.elements.length; i++) {
-      var element = pattern.elements[i];
-      // 检查数组元素是否匹配
-      if (element && element.type === 'Identifier' && element.name === identifier_name) {
-        return true;
-      }
-      // 递归检查嵌套解构
-      if (element && (element.type === 'ObjectPattern' || element.type === 'ArrayPattern')) {
-        if (this._isParameterInDestructuredPattern(element, identifier_name)) {
-          return true;
-        }
-      }
-    }
-  }
-
-  return false;
-};
-
+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 };