mm_eslint 1.4.4 → 1.4.6

package/detector.js

@@ -1,1239 +0,0 @@
-
-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;
-};
-
-module.exports = { Detector };