mm_eslint 1.4.3 → 1.4.4

package/detector.js

@@ -1,3664 +1,1239 @@
-/**
- * 命名规范检测器类
- */
-class Detector {
-  /**
-   * 构造函数
-   * @param {object} config 配置对象
-   */
-  constructor(config) {
-    // 直接将传入的配置对象赋值，确保原型方法不被丢失
-    this.config = config;
-
-    // 添加命名类型的中文描述
-    this.config.name_type_map = {
-      "class-name": "类名",
-      "function-name": "函数名",
-      "method-name": "方法名",
-      "variable-name": "变量名",
-      "param-name": "参数名",
-      "constant-name": "常量名",
-      "property-class-name": "属性类名",
-      "property-instance-class-name": "属性实例类名",
-      "property-method-name": "属性方法名",
-      "property-value-name": "属性值名",
-    };
-  }
-}
-
-/**
- * 检测类名
- * @param {string} class_name 类名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkClassName = function (class_name, node) {
-  try {
-    var rule = this.config.getRule("class-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(class_name, "class-name")) {
-      return null;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      class_name,
-      rule.styles,
-      "class-name",
-    );
-    if (style_err) {
-      // 如果有推荐建议，在风格错误消息后附加推荐
-      var smart_abbreviation = this._getSmartAbbreviation(
-        class_name,
-        "class-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== class_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查并推荐更合适的词汇
-    var rec_err = this._checkAndRecommend(class_name, "class-name");
-    if (rec_err) {
-      // 生成完整的建议名称
-      var recommended_full_name = class_name.replace(
-        new RegExp(rec_err.original_word, "i"),
-        rec_err.recommended_word,
-      );
-
-      return {
-        node: node,
-        message: "类名'" + class_name + "'，建议使用: " + recommended_full_name,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      class_name,
-      rule.min,
-      rule.max,
-      "class-name",
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        class_name,
-        "class-name",
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== class_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      class_name,
-      rule.single_word_len,
-      "class-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          class_name,
-          "class-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== class_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-
-      return {
-        node: node,
-        message: error_message,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(class_name, "class-name");
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-        rule_type: "class-name",
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测类名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检测方法名
- * @param {string} method_name 方法名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkMethodName = function (method_name, node) {
-  try {
-    var rule = this.config.getRule("method-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词（在所有检测之前）
-    if (this._isIgnoredWord(method_name, "method-name")) {
-      return null;
-    }
-
-    // 检查命名风格（支持公开方法和私有方法）
-    var style_err = null;
-    if (method_name.startsWith("_")) {
-      // 私有方法：检查是否符合私有方法命名规范
-      style_err = this._validate_naming_style(
-        method_name,
-        ["_camelCase"],
-        "method-name",
-      );
-    } else {
-      // 公开方法：检查是否符合公开方法命名规范
-      style_err = this._validate_naming_style(
-        method_name,
-        rule.styles,
-        "method-name",
-      );
-    }
-
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        method_name,
-        "method-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== method_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      method_name,
-      rule.min,
-      rule.max,
-      "method-name",
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        method_name,
-        "method-name",
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== method_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      method_name,
-      rule.single_word_len,
-      "method-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          method_name,
-          "method-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== method_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(method_name, "method-name");
-    if (forbid_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        method_name,
-        "method-name",
-      );
-      var error_message = forbid_err;
-      if (smart_abbreviation && smart_abbreviation !== method_name) {
-        error_message = forbid_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 如果没有错误但有推荐建议，返回优化建议
-    var smart_abbreviation = this._getSmartAbbreviation(
-      method_name,
-      "method-name",
-    );
-    if (smart_abbreviation && smart_abbreviation !== method_name) {
-      return {
-        node: node,
-        message:
-          "方法名'" +
-          method_name +
-          "'不是行业通用名，建议使用: " +
-          smart_abbreviation,
-        fix: function (fixer) {
-          return fixer.replaceText(node, smart_abbreviation);
-        },
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测方法名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检测函数名
- * @param {string} function_name 函数名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkFunctionName = function (function_name, node) {
-  try {
-    var rule = this.config.getRule("function-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(function_name, "function-name")) {
-      return null;
-    }
-
-    // 检查是否为私有函数（不允许私有函数）
-    if (function_name.startsWith("_")) {
-      // 生成建议：去掉下划线前缀，转换为公有函数
-      var public_function_name = function_name.substring(1);
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        public_function_name,
-        "function-name",
-      );
-      var recommended_name =
-        smart_abbreviation && smart_abbreviation !== public_function_name
-          ? smart_abbreviation
-          : public_function_name;
-
-      return {
-        node: node,
-        message:
-          "函数名'" +
-          function_name +
-          "'不允许声明私有函数，建议使用: " +
-          recommended_name,
-      };
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      function_name,
-      rule.styles,
-      "function-name",
-    );
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        function_name,
-        "function-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== function_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      function_name,
-      rule.min,
-      rule.max,
-      "function-name",
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        function_name,
-        "function-name",
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== function_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      function_name,
-      rule.single_word_len,
-      "function-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          function_name,
-          "function-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== function_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(function_name, "function-name");
-    if (forbid_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        function_name,
-        "function-name",
-      );
-      var error_message = forbid_err;
-      if (smart_abbreviation && smart_abbreviation !== function_name) {
-        error_message = forbid_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
-    var recommend_info = this._checkAndRecommend(
-      function_name,
-      "function-name",
-    );
-    if (recommend_info) {
-      // 如果有推荐建议，提示可以使用更简洁的词汇
-      return {
-        node: node,
-        message:
-          "函数名'" +
-          function_name +
-          "'建议使用: " +
-          recommend_info.recommended_name,
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测函数名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检测变量名
- * @param {string} variable_name 变量名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkVariableName = function (variable_name, node) {
-  try {
-    var rule = this.config.getRule("variable-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(variable_name, "variable-name")) {
-      return null;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      variable_name,
-      rule.styles,
-      "variable-name",
-    );
-    if (style_err) {
-      return {
-        node: node,
-        message: style_err,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      variable_name,
-      rule.min,
-      rule.max,
-      "variable-name",
-    );
-    if (len_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = len_err;
-      if (!len_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          variable_name,
-          "variable-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== variable_name) {
-          error_message = len_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      variable_name,
-      rule.single_word_len,
-      "variable-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          variable_name,
-          "variable-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== variable_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(variable_name, "variable-name");
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测变量名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检测参数名
- * @param {string} param_name 参数名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkParamName = function (param_name, node) {
-  try {
-    var rule = this.config.getRule("param-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(param_name, "param-name")) {
-      return null;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      param_name,
-      rule.styles,
-      "param-name",
-    );
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        param_name,
-        "param-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== param_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      param_name,
-      rule.min,
-      rule.max,
-      "param-name",
-    );
-    if (len_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = len_err;
-      if (!len_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          param_name,
-          "param-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== param_name) {
-          error_message = len_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      param_name,
-      rule.single_word_len,
-      "param-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          param_name,
-          "param-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== param_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(param_name, "param-name");
-    if (forbid_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        param_name,
-        "param-name",
-      );
-      var error_message = forbid_err;
-      if (smart_abbreviation && smart_abbreviation !== param_name) {
-        error_message = forbid_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测参数名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检测常量名
- * @param {string} constant_name 常量名
- * @param {object} node AST节点
- * @param {object} val_node 值节点（用于识别基础值）
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkConstantName = function (
-  constant_name,
-  node,
-  val_node,
-) {
-  try {
-    // 检查是否为解构导入（从模块导入的变量）
-    var is_destructured_import = this._isDestructuredImport(node);
-
-    // 如果是解构导入，则不进行命名检测
-    if (is_destructured_import) {
-      return null;
-    }
-
-    // 检查是否应该使用let而不是const
-    var should_use_let = this._shouldUseLetInsteadOfConst(node, val_node);
-
-    // 如果应该使用let，则提示开发者
-    if (should_use_let) {
-      return {
-        node: node,
-        message: `变量'${constant_name}'应该使用let而不是const声明，因为它不是真正的常量`,
-      };
-    }
-
-    // 根据值类型确定应该应用的命名规则
-    var rule_type = "constant-name"; // 默认使用常量命名规则
-    var allowed_styles = [];
-
-    // 检查是否为函数表达式或箭头函数
-    if (
-      val_node &&
-      (val_node.type === "FunctionExpression" ||
-        val_node.type === "ArrowFunctionExpression")
-    ) {
-      rule_type = "function-name";
-    }
-    // 检查是否为类表达式
-    else if (val_node && val_node.type === "ClassExpression") {
-      rule_type = "class-name";
-    }
-    // 检查是否为类实例（new表达式）
-    else if (val_node && val_node.type === "NewExpression") {
-      rule_type = "function-name"; // 类实例使用函数命名规则（camelCase）
-    }
-    // 检查是否为基础值类型
-    else if (val_node && this._isBaseValue(val_node)) {
-      rule_type = "constant-name";
-    }
-    // 检查是否为其他复杂类型（函数调用、变量引用等）
-    else if (val_node && this._isComplexType(val_node)) {
-      // 其他复杂类型不进行命名检测
-      return null;
-    }
-    // 其他情况不进行命名检测
-    else {
-      return null;
-    }
-
-    // 获取对应的命名规则
-    // 将属性规则类型映射到对应的基础规则类型（用于获取规则配置）
-    var rule_config_type = rule_type;
-    if (rule_type.startsWith('property-')) {
-      // 属性类名 -> 类名
-      if (rule_type === 'property-class-name') {
-        rule_config_type = 'class-name';
-      }
-      // 属性实例类名 -> 变量名
-      else if (rule_type === 'property-instance-class-name') {
-        rule_config_type = 'variable-name';
-      }
-      // 属性方法名 -> 方法名
-      else if (rule_type === 'property-method-name') {
-        rule_config_type = 'method-name';
-      }
-      // 属性值名 -> 变量名
-      else if (rule_type === 'property-value-name') {
-        rule_config_type = 'variable-name';
-      }
-    }
-    
-    var rule = this.config.getRule(rule_config_type);
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, rule_type)) {
-      return null;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      constant_name,
-      rule.styles,
-      rule_type,
-    );
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        constant_name,
-        rule_type,
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== constant_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-
-      return {
-        node: node,
-        message: error_message,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      constant_name,
-      rule.min,
-      rule.max,
-      rule_type,
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        constant_name,
-        rule_type,
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== constant_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
-      }
-
-      return {
-        node: node,
-        message: error_message,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      constant_name,
-      rule.single_word_len,
-      rule_type,
-    );
-    if (word_err) {
-      return {
-        node: node,
-        message: word_err,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(constant_name, rule_type);
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
-    var recommend_info = this._checkAndRecommend(constant_name, rule_type);
-    if (recommend_info) {
-      // 根据规则类型生成正确的错误消息
-      var name_type_text = "";
-      switch (rule_type) {
-        case "function-name":
-          name_type_text = "函数名";
-          break;
-        case "class-name":
-          name_type_text = "类名";
-          break;
-        case "constant-name":
-          name_type_text = "常量名";
-          break;
-        case "variable-name":
-          name_type_text = "变量名";
-          break;
-        default:
-          name_type_text = "名称";
-      }
-
-      return {
-        node: node,
-        message:
-          name_type_text +
-          "'" +
-          constant_name +
-          "'长度过长，最大长度为20字符，建议使用: " +
-          recommend_info.recommended_name,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测常量名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 验证命名风格
- * @param {string} name 名称
- * @param {Array} styles 允许的风格列表
- * @param {string} name_type 名称类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._validate_naming_style = function (name, styles, name_type) {
-  if (!name || !styles || !Array.isArray(styles)) {
-    return null;
-  }
-
-  for (var i = 0; i < styles.length; i++) {
-    var style = styles[i];
-    var regex = this.config.getRegex(style);
-    if (regex && regex.test(name)) {
-      return null;
-    }
-  }
-
-  var style_names = styles.join("或");
-
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-
-  return name_type_desc + "'" + name + "'不符合" + style_names + "命名风格";
-};
-
-/**
- * 检查名称长度
- * @param {string} name 名称
- * @param {number} min 最小长度
- * @param {number} max 最大长度
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkNameLength = function (name, min, max, name_type) {
-  if (!name) {
-    return "名称不能为空";
-  }
-
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-  var len = name.length;
-  if (len < min) {
-    return name_type_desc + "'" + name + "'长度过短，最小长度为" + min + "字符";
-  }
-
-  if (len > max) {
-    return name_type_desc + "'" + name + "'长度过长，最大长度为" + max + "字符";
-  }
-
-  return null;
-};
-
-/**
- * 检查单词长度
- * @param {string} name 名称
- * @param {number} max_word_len 最大单词长度
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
-  if (!name || !max_word_len) {
-    return null;
-  }
-
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-
-  // 处理私有标识符（开头的下划线）
-  var processed_name = name;
-  var has_private_prefix = false;
-
-  if (name.startsWith("_")) {
-    has_private_prefix = true;
-    processed_name = name.substring(1); // 去掉开头的下划线
-  }
-
-  // 分割单词（根据命名风格）
-  var words = [];
-
-  if (processed_name.includes("_")) {
-    words = processed_name.split("_");
-  } else if (processed_name.includes("-")) {
-    words = processed_name.split("-");
-  } else {
-    // 驼峰命名法分割（保持原词大小写）
-    words = processed_name.split(/(?=[A-Z])/);
-  }
-
-  // 如果存在私有标识符，添加空字符串表示私有标识符（不检查长度）
-  if (has_private_prefix) {
-    words.unshift("_");
-  }
-
-  // 过滤空字符串
-  words = words.filter(function (word) {
-    return word && word.length > 0;
-  });
-
-  // 如果是单个单词，则不检测单词长度
-  if (words.length <= 1) {
-    return null;
-  }
-
-  for (var i = 0; i < words.length; i++) {
-    var word = words[i];
-    // 跳过空字符串和私有标识符（单个下划线）
-    if (!word || word === "_") {
-      continue;
-    }
-
-    if (word.length > max_word_len) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(name, name_type);
-      var recommendation_text = "";
-      if (smart_abbreviation && smart_abbreviation !== name) {
-        recommendation_text = "，建议使用: " + smart_abbreviation;
-      }
-
-      return (
-        name_type_desc +
-        "'" +
-        name +
-        "'中的单词'" +
-        word +
-        "'过长，最大长度为" +
-        max_word_len +
-        "字符" +
-        recommendation_text
-      );
-    }
-  }
-
-  return null;
-};
-
-/**
- * 检查禁止词汇
- * @param {string} name 名称
- * @param {string} name_type 名称类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkForbiddenWords = function (name, name_type) {
-  if (!name || !name_type) {
-    return null;
-  }
-
-  var forbidden_words = this.config.getForbiddenWords(name_type);
-  if (!forbidden_words || !Array.isArray(forbidden_words)) {
-    return null;
-  }
-
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-  var name_lower = name.toLowerCase();
-
-  // 对于私有变量/方法（以_开头），如果是单个单词（移除_后没有其他分隔符），则跳过禁止词汇检查
-  if (name_lower.startsWith("_") && name.length > 2) {
-    // 移除前缀_后检查是否包含分隔符
-    var name_without_prefix = name.substring(1);
-    if (!name_without_prefix.includes("_") && !name_without_prefix.includes("-") && !/[A-Z]/.test(name_without_prefix)) {
-      return null; // 单个单词的私有变量，跳过检查
-    }
-  }
-
-  // 如果名称本身就是禁止词汇（即单个单词），则允许使用
-  for (var i = 0; i < forbidden_words.length; i++) {
-    var forbidden_word = forbidden_words[i].toLowerCase();
-    if (name_lower === forbidden_word) {
-      return null; // 单个单词允许使用
-    }
-  }
-
-  // 按单词边界分割名称（使用原始名称进行拆分，保持大小写信息）
-  var words = this._splitNameIntoWords(name);
-  
-  // 将拆分后的单词转换为小写进行比较
-  var words_lower = words.map(function(word) {
-    return word.toLowerCase();
-  });
-
-  // 检查每个单词是否在禁止词汇列表中
-  var found_forbidden_words = [];
-  
-  // 对于私有变量（以_开头），跳过第一个单词（即_）
-  var start_index = name_lower.startsWith("_") ? 1 : 0;
-  
-  for (var i = start_index; i < words_lower.length; i++) {
-    var word = words_lower[i];
-    // 跳过空字符串和单个字符
-    if (!word || word.length <= 1) {
-      continue;
-    }
-
-    for (var j = 0; j < forbidden_words.length; j++) {
-      var forbidden_word = forbidden_words[j].toLowerCase();
-      if (word === forbidden_word) {
-        // 记录找到的禁用词，但不立即返回
-        if (found_forbidden_words.indexOf(forbidden_word) === -1) {
-          found_forbidden_words.push(forbidden_word);
-        }
-      }
-    }
-  }
-
-  // 如果有找到禁用词，返回错误信息
-  if (found_forbidden_words.length > 0) {
-    var error_message = name_type_desc + "'" + name + "'包含禁止拼接词";
-    
-    if (found_forbidden_words.length === 1) {
-      error_message += "'" + found_forbidden_words[0] + "'";
-    } else {
-      // 多个禁用词，按优先级排序（长的优先）
-      found_forbidden_words.sort(function(a, b) {
-        return b.length - a.length; // 长的优先
-      });
-      error_message += "：" + found_forbidden_words.join(", ");
-    }
-    
-    return error_message;
-  }
-
-  return null;
-};
-
-/**
- * 按单词边界分割名称
- * @param {string} name 名称
- * @returns {Array} 单词数组
- */
-Detector.prototype._splitNameIntoWords = function (name) {
-  if (!name) {
-    return [];
-  }
-
-  var words = [];
-  var processed_name = name;
-  var has_private_prefix = false;
-
-  // 处理私有标识符（开头的下划线）
-  if (name.startsWith("_")) {
-    has_private_prefix = true;
-    processed_name = name.substring(1); // 去掉开头的下划线
-  }
-
-  // 如果移除_后为空，说明只有_，直接返回
-  if (!processed_name) {
-    return ["_"];
-  }
-
-  // 根据命名风格分割单词
-  if (processed_name.includes("_")) {
-    words = processed_name.split("_");
-  } else if (processed_name.includes("-")) {
-    words = processed_name.split("-");
-  } else {
-    // 驼峰命名法分割（保持原词大小写）
-    words = processed_name.split(/(?=[A-Z])/);
-  }
-
-  // 如果存在私有标识符，添加下划线作为第一个单词
-  if (has_private_prefix) {
-    words.unshift("_");
-  }
-
-  // 过滤空字符串
-  words = words.filter(function (word) {
-    return word && word.length > 0;
-  });
-
-  return words;
-};
-
-/**
- * 检查是否为第三方库的配置参数
- * @param {object} node AST节点
- * @param {object} parent_node 父节点
- * @returns {boolean} 是否为第三方库配置参数
- */
-Detector.prototype._isThirdPartyConfigProperty = function (node, parent_node) {
-  try {
-    // 处理新的父节点信息结构（包含node和parent属性）
-    var actual_parent_node = parent_node;
-    if (parent_node && typeof parent_node === "object" && parent_node.node) {
-      actual_parent_node = parent_node.node;
-    }
-
-    // 检查当前节点是否为对象字面量的属性
-    if (!actual_parent_node || actual_parent_node.type !== "ObjectExpression") {
-      return false;
-    }
-
-    // 递归查找调用表达式（处理嵌套对象的情况）
-    var findCallExpression = function (current_node) {
-      if (!current_node) {
-        return null;
-      }
-
-      if (current_node.type === "CallExpression") {
-        return current_node;
-      }
-
-      // 继续向上查找
-      return findCallExpression(current_node.parent);
-    };
-
-    // 优先使用新的父节点信息结构中的parent属性
-    var grandparent =
-      parent_node && typeof parent_node === "object" && parent_node.parent
-        ? parent_node.parent
-        : actual_parent_node.parent;
-
-    // 查找调用表达式
-    var call_expression = findCallExpression(grandparent);
-    if (!call_expression) {
-      return false;
-    }
-
-    // 检查方法调用是否来自外部模块（非当前文件定义的函数）
-    var callee = call_expression.callee;
-    if (!callee) {
-      return false;
-    }
-
-    // 如果是成员表达式（如 chokidar.watch），则认为是第三方库调用
-    if (callee.type === "MemberExpression") {
-      // 检查成员表达式的对象是否为模块导入变量
-      var is_module_import = this._isModuleImportVariable(callee.object);
-      if (is_module_import) {
-        return true;
-      }
-
-      // 对于其他成员表达式，也认为是第三方库调用（保守策略）
-      return true;
-    }
-
-    // 如果是标识符，检查是否是常见的第三方库函数名
-    if (callee.type === "Identifier") {
-      var common_third_party_functions = [
-        "watch",
-        "require",
-        "import",
-        "create",
-        "build",
-        "compile",
-        "parse",
-        "stringify",
-        "readFile",
-        "writeFile",
-        "mkdir",
-        "exec",
-        "spawn",
-        "fork",
-        "connect",
-        "listen",
-        "send",
-      ];
-
-      // 如果是常见的第三方库函数名，则认为是第三方库调用
-      if (common_third_party_functions.includes(callee.name)) {
-        return true;
-      }
-
-      // 检查标识符是否为模块导入变量
-      var is_module_import = this._isModuleImportVariable(callee);
-      if (is_module_import) {
-        return true;
-      }
-
-      // 对于其他标识符，暂时不认为是第三方库调用（避免误判）
-      return false;
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查第三方库配置参数时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 获取属性类型
- * @param {object} val_node 属性值节点
- * @param {string} prop_name 属性名
- * @param {object} parent_node 父节点
- * @returns {string} 属性类型
- */
-Detector.prototype._getPropType = function (val_node, prop_name, parent_node) {
-  if (!val_node) {
-    return "undefined_value"; // 未赋值类型
-  }
-
-  // 检查是否为null值
-  if (val_node.type === "NullLiteral") {
-    return "null_value"; // null值类型
-  }
-
-  // 检查是否为对象方法（在对象字面量中的函数）
-  if (
-    val_node &&
-    (val_node.type === "FunctionExpression" ||
-      val_node.type === "ArrowFunctionExpression")
-  ) {
-    return "method"; // 对象方法类型
-  }
-
-  // 检查是否为类引用（属性类）
-  if (
-    val_node.type === "Identifier" &&
-    val_node.name &&
-    val_node.name[0] === val_node.name[0].toUpperCase()
-  ) {
-    // 检查是否是特殊全局变量（如__dirname、__filename、process等）
-    var special_globals = [
-      "__dirname",
-      "__filename",
-      "process",
-      "console",
-      "module",
-      "exports",
-      "require",
-      "global",
-    ];
-    if (special_globals.includes(val_node.name)) {
-      return "value"; // 特殊全局变量应该识别为属性值
-    }
-
-    // 检查是否是类名引用（通常类名使用PascalCase）
-    return "class"; // 属性类类型
-  }
-
-  // 检查是否为类实例（new表达式）
-  if (val_node.type === "NewExpression") {
-    return "instance_class"; // 属性实例类类型
-  }
-
-  // 检查是否为函数调用（可能返回实例）
-  if (val_node.type === "CallExpression") {
-    // 检查是否调用的是构造函数
-    if (
-      val_node.callee &&
-      val_node.callee.type === "Identifier" &&
-      val_node.callee.name &&
-      val_node.callee.name[0] === val_node.callee.name[0].toUpperCase()
-    ) {
-      return "instance_class"; // 属性实例类类型
-    }
-
-    // 检查是否是工厂方法（返回实例）
-    var factory_methods = ["create", "make", "build", "get", "fetch"];
-    if (
-      val_node.callee &&
-      val_node.callee.type === "Identifier" &&
-      factory_methods.some(function (method) {
-        return val_node.callee.name.toLowerCase().startsWith(method);
-      })
-    ) {
-      return "instance_class"; // 工厂方法返回的实例
-    }
-
-    return "value"; // 默认值类型
-  }
-
-  // 检查是否为数组（包含对象实例）
-  if (val_node.type === "ArrayExpression") {
-    // 检查数组元素是否包含类实例
-    if (val_node.elements && val_node.elements.length > 0) {
-      var has_instance = val_node.elements.some(function (element) {
-        return element && element.type === "NewExpression";
-      });
-      if (has_instance) {
-        return "instance_class"; // 包含实例的数组
-      }
-    }
-    return "value"; // 普通数组
-  }
-
-  // 检查是否为对象字面量（可能包含类实例）
-  if (val_node.type === "ObjectExpression") {
-    // 检查对象属性是否包含类实例
-    if (val_node.properties && val_node.properties.length > 0) {
-      var has_instance = val_node.properties.some(function (property) {
-        return (
-          property && property.value && property.value.type === "NewExpression"
-        );
-      });
-      if (has_instance) {
-        return "instance_class"; // 包含实例的对象
-      }
-    }
-    return "value"; // 普通对象
-  }
-
-  // 检查是否为模板字面量（包含类实例）
-  if (val_node.type === "TemplateLiteral") {
-    // 检查模板表达式是否包含类实例
-    if (val_node.expressions && val_node.expressions.length > 0) {
-      var has_instance = val_node.expressions.some(function (expression) {
-        return expression && expression.type === "NewExpression";
-      });
-      if (has_instance) {
-        return "instance_class"; // 包含实例的模板
-      }
-    }
-    return "value"; // 普通模板
-  }
-
-  return "value";
-};
-
-/**
- * 检测属性名
- * @param {string} prop_name 属性名
- * @param {object} node AST节点
- * @param {object} val_node 属性值节点
- * @param {object} parent_node 父节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkPropertyName = function (
-  prop_name,
-  node,
-  val_node,
-  parent_node,
-) {
-  try {
-    // 检查是否为解构导入中的属性
-    var is_destructured_import = this._isDestructuredImportProperty(
-      node,
-      parent_node,
-    );
-
-    // 如果是解构导入中的属性，则不进行属性名检测
-    if (is_destructured_import) {
-      return null;
-    }
-
-    // 检查是否为第三方库的配置参数（方法调用中的对象字面量属性）
-    var is_third_party_config = this._isThirdPartyConfigProperty(
-      node,
-      parent_node,
-    );
-
-    // 如果是第三方库的配置参数，则不进行属性名检测
-    if (is_third_party_config) {
-      return null;
-    }
-
-    // 检查是否为 module.exports 中的属性
-    var is_module_exports = this._isModuleExportsProperty(node, parent_node);
-
-    // 如果是 module.exports 中的属性，则不进行属性名检测
-    if (is_module_exports) {
-      return null;
-    }
-
-    // 获取属性类型
-    var prop_type = this._getPropType(val_node, prop_name, parent_node);
-    var rule_type = "";
-
-    // 根据属性类型选择对应的规则
-    // 对于null值和未赋值属性，直接跳过命名规范检测
-    if (prop_type === "null_value" || prop_type === "undefined_value") {
-      return null; // 不进行命名规范检测
-    }
-
-    switch (prop_type) {
-      case "class":
-        rule_type = "property-class-name";
-        break;
-      case "instance_class":
-        rule_type = "property-instance-class-name";
-        break;
-      case "method":
-        rule_type = "property-method-name";
-        break;
-      case "value":
-      default:
-        rule_type = "property-value-name";
-        break;
-    }
-
-    // 将属性规则类型映射到对应的基础规则类型
-    var base_rule_type = rule_type;
-    if (rule_type.startsWith('property-')) {
-      // 属性类名 -> 类名
-      if (rule_type === 'property-class-name') {
-        base_rule_type = 'class-name';
-      }
-      // 属性实例类名 -> 变量名
-      else if (rule_type === 'property-instance-class-name') {
-        base_rule_type = 'variable-name';
-      }
-      // 属性方法名 -> 方法名
-      else if (rule_type === 'property-method-name') {
-        base_rule_type = 'method-name';
-      }
-      // 属性值名 -> 变量名
-      else if (rule_type === 'property-value-name') {
-        base_rule_type = 'variable-name';
-      }
-    }
-
-    // 检查忽略词
-    var ignored_words = this.config.getIgnoredWords(base_rule_type);
-    if (ignored_words && ignored_words.includes(prop_name)) {
-      return null; // 忽略词不进行命名规范检测
-    }
-
-    var rule = this.config.getRule(base_rule_type);
-    if (!rule) {
-      return null;
-    }
-
-    // 首先检查命名风格
-    var style_err = null;
-
-    if (rule_type === "property-value-name") {
-      // 对于属性值名，智能识别属性值类型并应用相应的命名规范
-      style_err = this._checkPropertyValueStyle(prop_name, val_node, rule_type);
-    } else if (rule_type === "property-method-name") {
-      // 属性方法：智能识别方法类型并提供准确的命名规范
-      style_err = this._checkPropertyMethodStyle(
-        prop_name,
-        val_node,
-        rule_type,
-      );
-    } else if (rule_type === "property-instance-class-name") {
-      // 属性实例类：智能识别实例类并提供准确的命名规范
-      style_err = this._checkPropertyInstanceClassStyle(
-        prop_name,
-        val_node,
-        rule_type,
-      );
-    } else if (rule_type === "property-class-name") {
-      // 属性类：智能识别类引用并提供准确的命名规范
-      style_err = this._checkPropertyClassStyle(prop_name, val_node, rule_type);
-    } else {
-      // 其他属性类型：使用原有逻辑
-      style_err = this._validate_naming_style(
-        prop_name,
-        rule.styles,
-        rule_type,
-      );
-    }
-
-    if (style_err) {
-      return {
-        node: node,
-        message: style_err,
-        rule_type: rule_type, // 添加规则类型信息
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      prop_name,
-      rule.min,
-      rule.max,
-      rule_type,
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(prop_name, rule_type);
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== prop_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
-      }
-
-      return {
-        node: node,
-        message: error_message,
-        rule_type: rule_type, // 添加规则类型信息
-      };
-    }
-
-    // 检查单词长度
-    // 对于私有属性值名（以_开头且长度>2），跳过单词长度检查，视为单个单词
-    var is_private_property = prop_name.startsWith("_");
-    if (!(is_private_property && prop_name.length > 2)) {
-      var word_err = this._checkWordLength(
-        prop_name,
-        rule.single_word_len,
-        rule_type,
-      );
-      if (word_err) {
-        // 检查错误消息是否已经包含建议
-        var error_message = word_err;
-        if (!word_err.includes("建议使用")) {
-          // 如果错误消息中不包含建议，则添加建议
-          var smart_abbreviation = this._getSmartAbbreviation(
-            prop_name,
-            rule_type,
-          );
-          if (smart_abbreviation && smart_abbreviation !== prop_name) {
-            error_message = word_err + "，建议使用: " + smart_abbreviation;
-          }
-        }
-
-        return {
-          node: node,
-          message: error_message,
-          rule_type: rule_type, // 添加规则类型信息
-        };
-      }
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(prop_name, base_rule_type);
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-        rule_type: rule_type, // 添加规则类型信息
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测属性名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查并推荐更合适的词汇
- * @param {string} name 名称
- * @param {string} name_type 名称类型
- * @returns {string|null} 推荐信息或null
- */
-Detector.prototype._checkAndRecommend = function (name, name_type) {
-  try {
-    var rec_words = this.config.getRecommendedWords(name_type);
-    if (!rec_words || Object.keys(rec_words).length === 0) {
-      return null;
-    }
-
-    var name_lower = name.toLowerCase();
-    var is_private = name.startsWith("_");
-    var name_without_prefix = is_private ? name.substring(1) : name;
-    var name_without_prefix_lower = name_without_prefix.toLowerCase();
-
-    // 检查每个推荐词映射
-    for (var rec_word in rec_words) {
-      if (rec_words.hasOwnProperty(rec_word)) {
-        var original_words = rec_words[rec_word];
-
-        // 检查名称是否包含任何一个原词
-        for (var i = 0; i < original_words.length; i++) {
-          var original_word = original_words[i].toLowerCase();
-
-          // 检查名称（去除私有前缀后）是否包含原词
-          if (name_without_prefix_lower.includes(original_word)) {
-            // 使用智能缩写生成完整的推荐名称
-            var smart_abbreviation = this._getSmartAbbreviation(
-              name,
-              name_type,
-            );
-            var recommended_name =
-              smart_abbreviation && smart_abbreviation !== name
-                ? smart_abbreviation
-                : name;
-
-            return {
-              type: "recommendation",
-              message:
-                "建议使用'" +
-                recommended_name +
-                "'替代'" +
-                name +
-                "'以获得更简洁的命名",
-              recommended_name: recommended_name,
-              original_name: name,
-              original_word: original_words[i],
-              recommended_word: rec_word,
-            };
-          }
-        }
-      }
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检查并推荐更合适的词汇时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查值是否为基础值类型
- * @param {object} val_node 值节点
- * @returns {boolean} 是否为基础值
- */
-Detector.prototype._isBaseValue = function (val_node) {
-  try {
-    if (!val_node) {
-      return false;
-    }
-
-    // 检查是否为基础值类型
-    var is_base_value = false;
-
-    switch (val_node.type) {
-      case "Literal": // 字面量：数字、字符串、布尔值
-        is_base_value = true;
-        break;
-      case "ArrayExpression": // 数组字面量
-        is_base_value = true;
-        break;
-      case "ObjectExpression": // 对象字面量
-        is_base_value = true;
-        break;
-      case "UnaryExpression": // 一元表达式（如 -1, +100）
-        if (val_node.operator === "-" || val_node.operator === "+") {
-          is_base_value = true;
-        }
-        break;
-      default:
-        is_base_value = false;
-    }
-
-    return is_base_value;
-  } catch (error) {
-    console.error("检查值是否为基础值类型时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否应该使用let而不是const声明变量
- * @param {object} node 变量声明节点
- * @param {object} val_node 值节点
- * @returns {boolean} 是否应该使用let
- */
-Detector.prototype._shouldUseLetInsteadOfConst = function (node, val_node) {
-  try {
-    if (!node || !val_node) {
-      return false;
-    }
-
-    // 检查是否为模块导入（需要排除的情况）
-    var is_module_import = this._isModuleImport(node, val_node);
-    if (is_module_import) {
-      return false;
-    }
-
-    // 检查是否为解构赋值
-    var is_destructuring = false;
-    if (node.parent && node.parent.type === "VariableDeclarator") {
-      var declarator = node.parent;
-      if (
-        declarator.id &&
-        (declarator.id.type === "ObjectPattern" ||
-          declarator.id.type === "ArrayPattern")
-      ) {
-        is_destructuring = true;
-      }
-    }
-
-    // 应该使用let的情况：
-    // 1. 函数调用（CallExpression）- 返回值可能变化
-    // 2. 变量引用（Identifier）- 可能被重新赋值
-    // 3. 条件表达式等可能产生不同结果的情况
-
-    var should_use_let = false;
-
-    // 检查是否为函数调用
-    if (val_node.type === "CallExpression") {
-      should_use_let = true;
-    }
-
-    // 检查是否为变量引用
-    if (val_node.type === "Identifier") {
-      should_use_let = true;
-    }
-
-    // 检查是否为解构赋值且右侧是复杂类型
-    var is_complex_type = this._isComplexType(val_node);
-    if (is_destructuring && is_complex_type) {
-      should_use_let = true;
-    }
-
-    return should_use_let;
-  } catch (error) {
-    console.error("检查是否应该使用let时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查值是否为复杂类型（方法、函数、实例等）
- * @param {object} val_node 值节点
- * @returns {boolean} 是否为复杂类型
- */
-Detector.prototype._isComplexType = function (val_node) {
-  try {
-    if (!val_node) {
-      return false;
-    }
-
-    // 检查是否为复杂类型
-    var is_complex_type = false;
-
-    switch (val_node.type) {
-      case "FunctionExpression": // 函数表达式
-      case "ArrowFunctionExpression": // 箭头函数
-      case "NewExpression": // new 实例化
-      case "CallExpression": // 函数调用
-      case "MemberExpression": // 成员表达式
-      case "Identifier": // 标识符（可能是变量或函数）
-      case "ClassExpression": // 类表达式
-      case "ThisExpression": // this表达式
-      case "TemplateLiteral": // 模板字符串
-        is_complex_type = true;
-        break;
-      default:
-        is_complex_type = false;
-    }
-
-    return is_complex_type;
-  } catch (error) {
-    console.error("检查值是否为复杂类型时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为模块导入（需要排除const检测的情况）
- * @param {object} node 变量声明节点
- * @param {object} val_node 值节点
- * @returns {boolean} 是否为模块导入
- */
-Detector.prototype._isModuleImport = function (node, val_node) {
-  try {
-    if (!node || !val_node) {
-      return false;
-    }
-
-    // 情况1：const xxx = require('module') - 直接模块导入
-    if (val_node.type === "CallExpression" && val_node.callee) {
-      // 检查是否为require调用
-      if (
-        val_node.callee.type === "Identifier" &&
-        val_node.callee.name === "require"
-      ) {
-        return true;
-      }
-
-      // 检查是否为import()动态导入
-      if (val_node.callee.type === "Import") {
-        return true;
-      }
-    }
-
-    // 情况2：const {xxx} = require('module') - 解构模块导入
-    if (node.parent && node.parent.type === "VariableDeclarator") {
-      var declarator = node.parent;
-
-      // 检查是否为解构赋值
-      if (declarator.id && declarator.id.type === "ObjectPattern") {
-        // 检查右侧是否为require调用
-        if (val_node.type === "CallExpression" && val_node.callee) {
-          if (
-            val_node.callee.type === "Identifier" &&
-            val_node.callee.name === "require"
-          ) {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为模块导入时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查标识符是否为模块导入变量
- * @param {object} node AST节点（Identifier类型）
- * @returns {boolean} 是否为模块导入变量
- */
-Detector.prototype._isModuleImportVariable = function (node) {
-  try {
-    if (!node || node.type !== "Identifier") {
-      return false;
-    }
-
-    // 检查变量声明是否为模块导入
-    if (node.parent && node.parent.parent) {
-      var variable_declaration = node.parent.parent;
-
-      // 检查是否为const声明
-      if (
-        variable_declaration.type === "VariableDeclaration" &&
-        variable_declaration.kind === "const"
-      ) {
-        // 检查声明中是否有require调用
-        var declarators = variable_declaration.declarations;
-        for (var i = 0; i < declarators.length; i++) {
-          var declarator = declarators[i];
-          if (declarator.init && declarator.init.type === "CallExpression") {
-            var init_call = declarator.init;
-            if (
-              init_call.callee &&
-              init_call.callee.type === "Identifier" &&
-              init_call.callee.name === "require"
-            ) {
-              return true;
-            }
-          }
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为模块导入变量时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为解构导入
- * @param {object} node AST节点
- * @returns {boolean} 是否为解构导入
- */
-Detector.prototype._isDestructuredImport = function (node) {
-  try {
-    if (!node || !node.parent) {
-      return false;
-    }
-
-    // 检查是否为解构导入模式
-    var is_destructured = false;
-
-    // 情况1：节点是Property.key（解构赋值中的属性键）
-    if (node.parent.type === "Property" && node.parent.key === node) {
-      var property = node.parent;
-
-      // 检查Property的父节点是否为ObjectPattern
-      if (property.parent && property.parent.type === "ObjectPattern") {
-        var object_pattern = property.parent;
-
-        // 检查ObjectPattern的父节点是否为VariableDeclarator
-        if (
-          object_pattern.parent &&
-          object_pattern.parent.type === "VariableDeclarator"
-        ) {
-          var declarator = object_pattern.parent;
-
-          // 检查右侧是否为require调用或其他模块导入
-          if (declarator.init) {
-            var init_type = declarator.init.type;
-
-            // 常见的模块导入方式
-            if (
-              init_type === "CallExpression" &&
-              declarator.init.callee &&
-              declarator.init.callee.name === "require"
-            ) {
-              is_destructured = true;
-            }
-
-            // 如果是ImportDeclaration（ES6导入）
-            if (init_type === "ImportExpression") {
-              is_destructured = true;
-            }
-          }
-        }
-      }
-    }
-
-    // 情况2：节点是VariableDeclarator（简单变量声明）
-    else if (node.parent.type === "VariableDeclarator") {
-      var declarator = node.parent;
-
-      // 检查是否为解构模式（ObjectPattern或ArrayPattern）
-      if (declarator.id && declarator.id.type === "ObjectPattern") {
-        // 检查右侧是否为require调用或其他模块导入
-        if (declarator.init) {
-          var init_type = declarator.init.type;
-
-          // 常见的模块导入方式
-          if (
-            init_type === "CallExpression" &&
-            declarator.init.callee &&
-            declarator.init.callee.name === "require"
-          ) {
-            is_destructured = true;
-          }
-
-          // 如果是ImportDeclaration（ES6导入）
-          if (init_type === "ImportExpression") {
-            is_destructured = true;
-          }
-        }
-      }
-    }
-
-    return is_destructured;
-  } catch (error) {
-    console.error("检查是否为解构导入时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为解构导入中的属性
- * @param {object} node 属性节点
- * @param {object} parent_node 父节点
- * @returns {boolean} 是否为解构导入中的属性
- */
-Detector.prototype._isDestructuredImportProperty = function (
-  node,
-  parent_node,
-) {
-  try {
-    // 处理新的父节点信息结构（包含node和parent属性）
-    var actual_parent_node = parent_node;
-    if (parent_node && typeof parent_node === "object" && parent_node.node) {
-      actual_parent_node = parent_node.node;
-    }
-
-    if (!node || !actual_parent_node) {
-      return false;
-    }
-
-    // 检查父节点是否为ObjectPattern（解构模式）
-    if (actual_parent_node.type === "ObjectPattern") {
-      // 检查父节点的父节点是否为VariableDeclarator
-      var actual_parent_parent =
-        parent_node && typeof parent_node === "object" && parent_node.parent
-          ? parent_node.parent
-          : actual_parent_node.parent;
-
-      if (
-        actual_parent_parent &&
-        actual_parent_parent.type === "VariableDeclarator"
-      ) {
-        var declarator = actual_parent_parent;
-
-        // 检查右侧是否为require调用或其他模块导入
-        if (declarator.init) {
-          var init_type = declarator.init.type;
-
-          // 常见的模块导入方式
-          if (
-            init_type === "CallExpression" &&
-            declarator.init.callee &&
-            declarator.init.callee.name === "require"
-          ) {
-            return true;
-          }
-
-          // 如果是ImportDeclaration（ES6导入）
-          if (init_type === "ImportExpression") {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为解构导入中的属性时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为函数赋值（函数表达式或箭头函数）
- * @param {object} node AST节点
- * @returns {boolean} 是否为函数赋值
- */
-Detector.prototype._isFunctionAssignment = function (node) {
-  try {
-    if (!node) {
-      return false;
-    }
-
-    // 检查节点是否为解构赋值中的属性
-    if (node.type === "Property" && node.key === node) {
-      // 检查父节点是否为ObjectPattern
-      if (node.parent && node.parent.type === "ObjectPattern") {
-        // 检查父节点的父节点是否为VariableDeclarator
-        if (
-          node.parent.parent &&
-          node.parent.parent.type === "VariableDeclarator"
-        ) {
-          var declarator = node.parent.parent;
-
-          // 检查右侧是否为函数表达式或箭头函数
-          if (declarator.init) {
-            var init_type = declarator.init.type;
-
-            // 函数表达式
-            if (init_type === "FunctionExpression") {
-              return true;
-            }
-
-            // 箭头函数
-            if (init_type === "ArrowFunctionExpression") {
-              return true;
-            }
-
-            // 函数调用（可能返回函数）
-            if (init_type === "CallExpression") {
-              return true;
-            }
-          }
-        }
-      }
-    }
-
-    // 检查节点是否为解构赋值中的数组元素
-    if (
-      node.type === "Identifier" &&
-      node.parent &&
-      node.parent.type === "ArrayPattern"
-    ) {
-      // 检查父节点的父节点是否为VariableDeclarator
-      if (
-        node.parent.parent &&
-        node.parent.parent.type === "VariableDeclarator"
-      ) {
-        var declarator = node.parent.parent;
-
-        // 检查右侧是否为函数表达式或箭头函数
-        if (declarator.init) {
-          var init_type = declarator.init.type;
-
-          // 函数表达式
-          if (init_type === "FunctionExpression") {
-            return true;
-          }
-
-          // 箭头函数
-          if (init_type === "ArrowFunctionExpression") {
-            return true;
-          }
-
-          // 函数调用（可能返回函数）
-          if (init_type === "CallExpression") {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为函数赋值时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查常量名是否符合规范
- * @param {string} constant_name 常量名
- * @returns {boolean} 是否符合规范
- */
-Detector.prototype._isConstantNameValid = function (constant_name) {
-  try {
-    var rule = this.config.getRule("constant-name");
-    if (!rule) {
-      return false;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      constant_name,
-      rule.styles,
-      "constant-name",
-    );
-    return !style_err;
-  } catch (error) {
-    console.error("检查常量名是否符合规范时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为忽略词
- * @param {string} name 名称
- * @param {string} name_type 名称类型
- * @returns {boolean} 是否为忽略词
- */
-Detector.prototype._isIgnoredWord = function (name, name_type) {
-  try {
-    var ignored_words = this.config.getIgnoredWords(name_type);
-    if (!ignored_words || !Array.isArray(ignored_words)) {
-      return false;
-    }
-
-    var name_lower = name.toLowerCase();
-    for (var i = 0; i < ignored_words.length; i++) {
-      if (ignored_words[i].toLowerCase() === name_lower) {
-        return true;
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为忽略词时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 生成推荐命名
- * @param {string} original_name 原始名称
- * @param {string} long_word 过长的单词
- * @param {string} name_type 名称类型
- * @returns {string|null} 推荐命名或null
- */
-Detector.prototype._generateRecommendedName = function (
-  original_name,
-  long_word,
-  name_type,
-) {
-  try {
-    // 获取推荐词映射
-    var recommended_words = this.config.getRecommendedWords(name_type);
-    if (!recommended_words || Object.keys(recommended_words).length === 0) {
-      return null;
-    }
-
-    var long_word_lower = long_word.toLowerCase();
-    var is_private = original_name.startsWith("_");
-    var original_name_without_prefix = is_private
-      ? original_name.substring(1)
-      : original_name;
-
-    // 检查推荐词映射中是否有对应的缩写
-    for (var short_word in recommended_words) {
-      if (recommended_words.hasOwnProperty(short_word)) {
-        var original_words = recommended_words[short_word];
-
-        // 检查过长的单词是否在推荐词的原词列表中
-        for (var i = 0; i < original_words.length; i++) {
-          var original_word = original_words[i].toLowerCase();
-          if (long_word_lower === original_word) {
-            // 生成推荐命名：将原始名称中的长单词替换为推荐的缩写，保持私有前缀
-            var recommended_name_without_prefix =
-              original_name_without_prefix.replace(long_word, short_word);
-            var recommended_name = is_private
-              ? "_" + recommended_name_without_prefix
-              : recommended_name_without_prefix;
-            return recommended_name;
-          }
-        }
-      }
-    }
-
-    return null;
-  } catch (error) {
-    console.error("生成推荐命名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 转换命名风格
- * @param {string} name 原始名称
- * @param {string} target_style 目标命名风格
- * @param {string} name_type 名称类型
- * @returns {string} 转换后的名称
- */
-Detector.prototype._convertNamingStyle = function (
-  name,
-  target_style,
-  name_type,
-) {
-  try {
-    if (!name || !target_style) {
-      return name;
-    }
-
-    // 处理私有标识符
-    var has_private_prefix = name.startsWith("_");
-    var processed_name = has_private_prefix ? name.substring(1) : name;
-
-    // 分割单词
-    var words = this._splitNameIntoWords(processed_name);
-
-    // 过滤空字符串和私有标识符
-    words = words.filter(function (word) {
-      return word && word.length > 0 && word !== "_";
-    });
-
-    if (words.length === 0) {
-      return name;
-    }
-
-    var converted_name = "";
-
-    // 根据目标风格转换
-    switch (target_style) {
-      case "camelCase":
-        // 小驼峰命名法
-        converted_name = words
-          .map(function (word, index) {
-            if (index === 0) {
-              return word.toLowerCase();
-            }
-            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-          })
-          .join("");
-        break;
-
-      case "_camelCase":
-        // 私有小驼峰命名法
-        converted_name =
-          "_" +
-          words
-            .map(function (word, index) {
-              if (index === 0) {
-                return word.toLowerCase();
-              }
-              return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-            })
-            .join("");
-        break;
-
-      case "PascalCase":
-        // 大驼峰命名法
-        converted_name = words
-          .map(function (word) {
-            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-          })
-          .join("");
-        break;
-
-      case "snake_case":
-        // 小写蛇形命名法
-        converted_name = words
-          .map(function (word) {
-            return word.toLowerCase();
-          })
-          .join("_");
-        break;
-
-      case "_snake_case":
-        // 私有小写蛇形命名法
-        converted_name =
-          "_" +
-          words
-            .map(function (word) {
-              return word.toLowerCase();
-            })
-            .join("_");
-        break;
-
-      case "UPPER_SNAKE_CASE":
-        // 大写蛇形命名法
-        converted_name = words
-          .map(function (word) {
-            return word.toUpperCase();
-          })
-          .join("_");
-        break;
-
-      default:
-        converted_name = name;
-    }
-
-    // 如果原始名称有私有前缀但目标风格不是私有风格，则添加私有前缀
-    if (
-      has_private_prefix &&
-      !target_style.startsWith("_") &&
-      !converted_name.startsWith("_")
-    ) {
-      converted_name = "_" + converted_name;
-    }
-
-    return converted_name;
-  } catch (error) {
-    console.error("转换命名风格时出错:", error);
-    return name;
-  }
-};
-
-/**
- * 获取命名修复建议
- * @param {string} name 原始名称
- * @param {string} name_type 名称类型
- * @param {string} error_message 错误信息
- * @returns {object|null} 修复建议对象
- */
-Detector.prototype._getFixSuggestion = function (
-  name,
-  name_type,
-  error_message,
-) {
-  try {
-    var rule = this.config.getRule(name_type);
-    if (!rule || !rule.styles || rule.styles.length === 0) {
-      return null;
-    }
-
-    // 根据名称类型智能选择目标风格
-    var target_style = this._getSmartTargetStyle(name, name_type, rule.styles);
-
-    // 生成修复后的名称
-    var fixed_name = this._convertNamingStyle(name, target_style, name_type);
-
-    // 优先检查错误消息中是否有建议使用的名称
-    if (error_message && error_message.includes("建议使用:")) {
-      // 从错误消息中提取建议的名称
-      var suggestion_match = error_message.match(/建议使用:\s*([\w_]+)/);
-      if (suggestion_match && suggestion_match[1]) {
-        fixed_name = suggestion_match[1];
-
-        // 对于私有方法（以_开头），根据错误消息确定正确的命名风格
-        if (name_type === "method-name" && fixed_name.startsWith("_")) {
-          // 检查错误消息中是否指定了命名风格
-          if (error_message.includes("_camelCase")) {
-            target_style = "_camelCase";
-          } else if (error_message.includes("_snake_case")) {
-            target_style = "_snake_case";
-          } else {
-            // 默认使用_snake_case风格
-            target_style = "_snake_case";
-          }
-        }
-
-        // 验证建议的名称是否有效
-        var suggestion_validation = this._validate_naming_style(
-          fixed_name,
-          [target_style],
-          name_type,
-        );
-
-        if (suggestion_validation) {
-          // 建议的名称无效，回退到原始转换逻辑
-          fixed_name = this._convertNamingStyle(name, target_style, name_type);
-        }
-      }
-    }
-
-    // 检查是否需要智能缩写（长度过长的问题）
-    if (error_message && error_message.includes("长度过长")) {
-      // 如果错误消息中已经有建议名称，使用建议名称
-      if (error_message.includes("建议使用:")) {
-        // 已经处理过建议名称，直接使用
-      } else {
-        // 如果没有建议名称，使用智能缩写
-        fixed_name = this._getSmartAbbreviation(name, name_type);
-
-        // 如果智能缩写后名称仍然相同，则不提供修复建议
-        if (fixed_name === name) {
-          return null;
-        }
-
-        // 支持多次缩写直到满足长度要求
-        var max_length = rule.max || 20;
-        var current_name = fixed_name;
-        var max_attempts = 5; // 最多尝试5次
-
-        for (var attempt = 0; attempt < max_attempts; attempt++) {
-          if (current_name.length <= max_length) {
-            break; // 长度满足要求，退出循环
-          }
-
-          var next_name = this._getSmartAbbreviation(current_name, name_type);
-          if (next_name === current_name) {
-            break; // 无法进一步缩写，退出循环
-          }
-          current_name = next_name;
-        }
-
-        fixed_name = current_name;
-      }
-    } else if (fixed_name === name) {
-      // 其他情况下，转换后名称相同，不提供修复建议
-      return null;
-    }
-
-    // 检查修复后的名称是否仍然有错误
-    var fixed_style_err = this._validate_naming_style(
-      fixed_name,
-      [target_style],
-      name_type,
-    );
-    if (fixed_style_err) {
-      // 修复后的名称仍然有错误，尝试其他风格
-      for (var i = 1; i < rule.styles.length; i++) {
-        var alternative_style = rule.styles[i];
-        var alternative_name = this._convertNamingStyle(
-          name,
-          alternative_style,
-          name_type,
-        );
-        var alternative_err = this._validate_naming_style(
-          alternative_name,
-          [alternative_style],
-          name_type,
-        );
-
-        if (!alternative_err) {
-          fixed_name = alternative_name;
-          target_style = alternative_style;
-          break;
-        }
-      }
-    }
-
-    // 如果名称长度仍然过长，且错误消息中没有建议名称，进行智能缩写处理
-    if (
-      error_message &&
-      error_message.includes("长度过长") &&
-      !error_message.includes("建议使用:")
-    ) {
-      fixed_name = this._getSmartAbbreviation(name, name_type);
-    }
-
-    return {
-      fixed_name: fixed_name,
-      target_style: target_style,
-    };
-  } catch (error) {
-    console.error("获取命名修复建议时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 智能缩写处理（针对长度过长的名称）
- * @param {string} name 原始名称
- * @param {string} name_type 名称类型
- * @returns {string} 缩写后的名称
- */
-Detector.prototype._getSmartAbbreviation = function (name, name_type) {
-  try {
-    // 处理私有标识符
-    var has_private_prefix = name.startsWith("_");
-    var processed_name = has_private_prefix ? name.substring(1) : name;
-
-    // 分割单词
-    var words = this._splitNameIntoWords(processed_name);
-
-    // 过滤空字符串
-    words = words.filter(function (word) {
-      return word && word.length > 0;
-    });
-
-    if (words.length === 0) {
-      return name;
-    }
-
-    // 获取配置中的推荐词映射
-    var rec_words = {};
-    if (
-      this.config.getRecommendedWords &&
-      typeof this.config.getRecommendedWords === "function"
-    ) {
-      rec_words = this.config.getRecommendedWords(name_type);
-    }
-
-    // 获取配置中的禁止词列表（作为禁止拼接词）
-    var forbidden_words = [];
-    if (
-      this.config.getForbiddenWords &&
-      typeof this.config.getForbiddenWords === "function"
-    ) {
-      forbidden_words = this.config.getForbiddenWords(name_type);
-    }
-
-    if (!rec_words || Object.keys(rec_words).length === 0) {
-      return name;
-    }
-
-    // 处理每个单词，使用推荐词替换
-    var processed_words = [];
-    for (var i = 0; i < words.length; i++) {
-      var word = words[i];
-      var word_lower = word.toLowerCase();
-      var replaced = false;
-
-      // 检查是否需要替换为推荐词
-      for (var rec_word in rec_words) {
-        if (rec_words.hasOwnProperty(rec_word)) {
-          var original_words = rec_words[rec_word];
-
-          for (var j = 0; j < original_words.length; j++) {
-            var original_word = original_words[j].toLowerCase();
-
-            // 如果当前单词包含原词（不区分大小写），则替换为推荐词
-            if (word_lower.includes(original_word)) {
-              // 保持首字母大小写
-              if (word[0] === word[0].toUpperCase()) {
-                processed_words.push(
-                  rec_word[0].toUpperCase() + rec_word.substring(1),
-                );
-              } else {
-                processed_words.push(rec_word);
-              }
-              replaced = true;
-              break;
-            }
-          }
-
-          if (replaced) break;
-        }
-      }
-
-      // 如果没有找到推荐词，检查是否为禁止拼接词
-      if (!replaced) {
-        var is_forbidden = false;
-        for (var f = 0; f < forbidden_words.length; f++) {
-          var forbidden_word = forbidden_words[f].toLowerCase();
-          if (word_lower === forbidden_word) {
-            is_forbidden = true;
-            break;
-          }
-        }
-
-        // 如果不是禁止拼接词，保留原词
-        if (!is_forbidden) {
-          processed_words.push(word);
-        }
-      }
-    }
-
-    // 根据名称类型确定目标风格
-    var target_style = "camelCase";
-    if (name_type === "constant-name") {
-      target_style = "UPPER_SNAKE_CASE";
-    } else if (
-      name_type === "class-name" ||
-      name_type === "property-class-name"
-    ) {
-      target_style = "PascalCase";
-    } else if (
-      name_type === "variable-name" ||
-      name_type === "property-value-name"
-    ) {
-      target_style = "snake_case";
-    }
-    // 函数名、方法名等保持默认的 camelCase
-
-    var abbreviated_name = "";
-
-    switch (target_style) {
-      case "camelCase":
-        for (var k = 0; k < processed_words.length; k++) {
-          if (k === 0) {
-            abbreviated_name += processed_words[k].toLowerCase();
-          } else {
-            abbreviated_name +=
-              processed_words[k][0].toUpperCase() +
-              processed_words[k].substring(1).toLowerCase();
-          }
-        }
-        break;
-      case "PascalCase":
-        for (var l = 0; l < processed_words.length; l++) {
-          abbreviated_name +=
-            processed_words[l][0].toUpperCase() +
-            processed_words[l].substring(1).toLowerCase();
-        }
-        break;
-      case "snake_case":
-        abbreviated_name = processed_words.join("_").toLowerCase();
-        break;
-      case "UPPER_SNAKE_CASE":
-        abbreviated_name = processed_words.join("_").toUpperCase();
-        break;
-      default:
-        abbreviated_name = processed_words.join("");
-    }
-
-    // 恢复私有标识符
-    if (has_private_prefix) {
-      abbreviated_name = "_" + abbreviated_name;
-    }
-
-    // 检查长度：如果缩写后长度没有变短，尝试其他策略
-    if (abbreviated_name.length >= name.length) {
-      return name;
-    }
-
-    // 如果缩写后仍然超过最大长度，尝试进一步优化
-    var max_length = 20;
-    if (abbreviated_name.length > max_length) {
-      // 策略1: 截断过长的单词
-      var optimized_words = [];
-      for (var k = 0; k < processed_words.length; k++) {
-        var word = processed_words[k];
-        if (word.length > 8) {
-          // 截断过长的单词到8个字符
-          optimized_words.push(word.substring(0, 8));
-        } else {
-          optimized_words.push(word);
-        }
-      }
-
-      // 重新生成名称
-      var optimized_name = "";
-      switch (target_style) {
-        case "camelCase":
-          for (var m = 0; m < optimized_words.length; m++) {
-            if (m === 0) {
-              optimized_name += optimized_words[m].toLowerCase();
-            } else {
-              optimized_name +=
-                optimized_words[m][0].toUpperCase() +
-                optimized_words[m].substring(1).toLowerCase();
-            }
-          }
-          break;
-        case "PascalCase":
-          for (var n = 0; n < optimized_words.length; n++) {
-            optimized_name +=
-              optimized_words[n][0].toUpperCase() +
-              optimized_words[n].substring(1).toLowerCase();
-          }
-          break;
-        case "snake_case":
-          optimized_name = optimized_words.join("_").toLowerCase();
-          break;
-        case "UPPER_SNAKE_CASE":
-          optimized_name = optimized_words.join("_").toUpperCase();
-          break;
-        default:
-          optimized_name = optimized_words.join("");
-      }
-
-      // 恢复私有标识符
-      if (has_private_prefix) {
-        optimized_name = "_" + optimized_name;
-      }
-
-      // 如果优化后名称更短，使用优化后的名称
-      if (optimized_name.length < abbreviated_name.length) {
-        abbreviated_name = optimized_name;
-      }
-
-      // 如果仍然超过长度，尝试移除不重要的单词
-      if (abbreviated_name.length > max_length && processed_words.length > 2) {
-        // 保留前2个和后1个单词
-        var important_words = [
-          processed_words[0],
-          processed_words[1],
-          processed_words[processed_words.length - 1],
-        ];
-        
-        // 根据目标风格生成简化名称
-        var simplified_name = "";
-        switch (target_style) {
-          case "camelCase":
-            for (var o = 0; o < important_words.length; o++) {
-              if (o === 0) {
-                simplified_name += important_words[o].toLowerCase();
-              } else {
-                simplified_name +=
-                  important_words[o][0].toUpperCase() +
-                  important_words[o].substring(1).toLowerCase();
-              }
-            }
-            break;
-          case "PascalCase":
-            for (var p = 0; p < important_words.length; p++) {
-              simplified_name +=
-                important_words[p][0].toUpperCase() +
-                important_words[p].substring(1).toLowerCase();
-            }
-            break;
-          case "snake_case":
-            simplified_name = important_words.join("_").toLowerCase();
-            break;
-          case "UPPER_SNAKE_CASE":
-            simplified_name = important_words.join("_").toUpperCase();
-            break;
-          default:
-            simplified_name = important_words.join("");
-        }
-
-        // 恢复私有标识符
-        if (has_private_prefix) {
-          simplified_name = "_" + simplified_name;
-        }
-
-        // 如果简化后名称更短且不超过最大长度，使用简化后的名称
-        if (
-          simplified_name.length <= max_length &&
-          simplified_name.length < abbreviated_name.length
-        ) {
-          abbreviated_name = simplified_name;
-        }
-      }
-    }
-
-    return abbreviated_name;
-  } catch (error) {
-    console.error("智能缩写处理时出错:", error);
-    return name;
-  }
-};
-
-/**
- * 智能选择目标命名风格
- * @param {string} name 原始名称
- * @param {string} name_type 名称类型
- * @param {array} available_styles 可用的命名风格
- * @returns {string} 目标命名风格
- */
-Detector.prototype._getSmartTargetStyle = function (
-  name,
-  name_type,
-  available_styles,
-) {
-  try {
-    // 默认使用第一个风格
-    var target_style = available_styles[0];
-
-    // 根据名称类型和原始名称特征智能选择
-    switch (name_type) {
-      case "property-value-name":
-        // 属性值：根据是否为私有属性和值类型选择风格
-        if (name.startsWith("_")) {
-          // 私有属性值：优先使用私有蛇形命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "_snake_case";
-            }) || target_style;
-        } else {
-          // 公开属性值：优先使用蛇形命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "snake_case";
-            }) || target_style;
-        }
-        break;
-
-      case "property-class-name":
-        // 属性类：根据是否为私有类选择风格
-        if (name.startsWith("_")) {
-          // 私有属性类：优先使用私有大驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "_PascalCase";
-            }) || target_style;
-        } else {
-          // 公开属性类：优先使用大驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "PascalCase";
-            }) || target_style;
-        }
-        break;
-
-      case "property-instance-class-name":
-      case "property-method-name":
-        // 属性实例类和属性方法：根据是否为私有选择风格
-        if (name.startsWith("_")) {
-          // 私有实例类/方法：优先使用私有小驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "_camelCase";
-            }) || target_style;
-        } else {
-          // 公开实例类/方法：优先使用小驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "camelCase";
-            }) || target_style;
-        }
-        break;
-
-      default:
-        // 其他类型：使用默认风格
-        target_style = available_styles[0];
-    }
-
-    return target_style;
-  } catch (error) {
-    console.error("智能选择目标命名风格时出错:", error);
-    return available_styles[0];
-  }
-};
-
-/**
- * 检测解构赋值中的常量名
- * @param {string} constant_name 常量名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkConstantNameForDestructuring = function (
-  constant_name,
-  node,
-) {
-  try {
-    // 解构赋值中的变量应该使用变量规则，而不是常量规则
-    var rule = this.config.getRule("variable-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, "variable-name")) {
-      return null;
-    }
-
-    // 检查是否为解构导入（从模块导入的变量）
-    var is_destructured_import = this._isDestructuredImport(node);
-
-    // 如果是解构导入，则不进行变量检测
-    if (is_destructured_import) {
-      return null;
-    }
-
-    // 检查是否为函数赋值（函数表达式或箭头函数）
-    var is_function_assignment = this._isFunctionAssignment(node);
-
-    // 如果是函数赋值，允许camelCase命名风格
-    var allowed_styles = [];
-    if (is_function_assignment) {
-      allowed_styles = ["camelCase", "UPPER_SNAKE_CASE"];
-    } else {
-      allowed_styles = rule.styles;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      constant_name,
-      allowed_styles,
-      "variable-name",
-    );
-    if (style_err) {
-      return {
-        node: node,
-        message: style_err,
-      };
-    }
-
-    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
-    var recommend_info = this._checkAndRecommend(
-      constant_name,
-      "variable-name",
-    );
-    if (recommend_info) {
-      // 如果有推荐建议，在错误消息中提示可以使用更简洁的词汇
-      return {
-        node: node,
-        message:
-          "变量名'" +
-          constant_name +
-          "'长度过长，最大长度为20字符，建议使用: " +
-          recommend_info.recommended_name,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      constant_name,
-      rule.min,
-      rule.max,
-      "variable-name",
-    );
-    if (len_err) {
-      return {
-        node: node,
-        message: len_err,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      constant_name,
-      rule.single_word_len,
-      "constant-name",
-    );
-    if (word_err) {
-      return {
-        node: node,
-        message: word_err,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(constant_name, "constant-name");
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测解构赋值常量名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性值命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyValueStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词
-    var forbid_err = this._checkForbiddenWords(prop_name, rule_type);
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查属性值类型，智能选择命名规范
-    var is_constant_value = this._isConstantValue(val_node);
-    var is_private_property = prop_name.startsWith("_");
-
-    // 属性值应该允许满足常量或变量命名规则之一即可
-    // 构建允许的命名风格列表
-    var allowed_styles = [];
-
-    // 常量值：允许常量命名规范
-    if (is_constant_value) {
-      allowed_styles.push("UPPER_SNAKE_CASE");
-    }
-
-    // 私有属性：允许私有变量命名规范
-    if (is_private_property) {
-      allowed_styles.push("_snake_case");
-    }
-
-    // 普通属性值：允许变量命名规范
-    allowed_styles.push("snake_case");
-
-    // 检查命名风格 - 只要满足其中一种风格即可
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性值名'" + prop_name + "'不符合" + style_names + "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性值命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性方法命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyMethodStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词 - 使用 method-name 规则类型
-    var forbid_err = this._checkForbiddenWords(prop_name, "method-name");
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查是否为私有属性方法
-    var is_private_method = prop_name.startsWith("_");
-
-    // 属性方法应该允许满足公开方法或私有方法命名规则之一即可
-    // 构建允许的命名风格列表
-    var allowed_styles = [];
-
-    // 私有属性方法：允许私有方法命名规范
-    if (is_private_method) {
-      allowed_styles.push("_camelCase");
-    }
-
-    // 公开属性方法：允许公开方法命名规范
-    allowed_styles.push("camelCase");
-
-    // 检查命名风格 - 只要满足其中一种风格即可
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性方法名'" + prop_name + "'不符合" + style_names + "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性方法命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性实例类命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyInstanceClassStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词
-    var forbid_err = this._checkForbiddenWords(prop_name, "method-name");
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查是否为私有属性实例类
-    var is_private_instance = prop_name.startsWith("_");
-
-    // 属性类实例应该允许满足公开或私有命名规则之一即可
-    // 构建允许的命名风格列表
-    var allowed_styles = [];
-
-    // 私有属性实例类：允许私有实例类命名规范
-    if (is_private_instance) {
-      allowed_styles.push("_camelCase");
-    }
-
-    // 公开属性实例类：允许公开实例类命名规范
-    allowed_styles.push("camelCase");
-
-    // 检查命名风格 - 只要满足其中一种风格即可
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性实例类名'" +
-      prop_name +
-      "'不符合" +
-      style_names +
-      "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性实例类命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性类命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyClassStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词
-    var forbid_err = this._checkForbiddenWords(prop_name, "class-name");
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查是否为私有属性类
-    var is_private_class = prop_name.startsWith("_");
-
-    // 根据属性类类型选择合适的命名规范
-    var allowed_styles = [];
-
-    if (is_private_class) {
-      // 私有属性类：使用私有类命名规范
-      allowed_styles = ["_PascalCase"];
-    } else {
-      // 公开属性类：使用类命名规范
-      allowed_styles = ["PascalCase"];
-    }
-
-    // 检查命名风格
-    var style_err = null;
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性类名'" + prop_name + "'不符合" + style_names + "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性类命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查是否为常量值
- * @param {object} val_node 属性值节点
- * @returns {boolean} 是否为常量值
- */
-Detector.prototype._isConstantValue = function (val_node) {
-  try {
-    if (!val_node) {
-      return false;
-    }
-
-    // 常量值类型：字面量、基础值、不可变值
-    var is_constant = false;
-
-    switch (val_node.type) {
-      case "Literal": // 字面量：数字、字符串、布尔值
-        is_constant = true;
-        break;
-      case "UnaryExpression": // 一元表达式（如 -1, +100）
-        if (val_node.operator === "-" || val_node.operator === "+") {
-          is_constant = true;
-        }
-        break;
-      case "ArrayExpression": // 数组字面量（空数组或包含常量值的数组）
-        if (!val_node.elements || val_node.elements.length === 0) {
-          is_constant = true;
-        } else {
-          // 检查数组元素是否都是常量值
-          is_constant = val_node.elements.every(function (element) {
-            return this._isConstantValue(element);
-          }, this);
-        }
-        break;
-      case "ObjectExpression": // 对象字面量（空对象或包含常量值的对象）
-        if (!val_node.properties || val_node.properties.length === 0) {
-          is_constant = true;
-        } else {
-          // 检查对象属性值是否都是常量值
-          is_constant = val_node.properties.every(function (property) {
-            return (
-              property &&
-              property.value &&
-              this._isConstantValue(property.value)
-            );
-          }, this);
-        }
-        break;
-      case "TemplateLiteral": // 模板字面量（包含常量值的模板）
-        if (!val_node.expressions || val_node.expressions.length === 0) {
-          is_constant = true;
-        } else {
-          // 检查模板表达式是否都是常量值
-          is_constant = val_node.expressions.every(function (expression) {
-            return this._isConstantValue(expression);
-          }, this);
-        }
-        break;
-      default:
-        is_constant = false;
-    }
-
-    return is_constant;
-  } catch (error) {
-    console.error("检查是否为常量值时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检测参数声明与函数内部引用是否一致
- * @param {object} context ESLint上下文
- * @param {object} node 函数节点（FunctionDeclaration、FunctionExpression、ArrowFunctionExpression）
- */
-Detector.prototype._checkParamReferences = function (context, node) {
-  try {
-    // 获取函数参数列表
-    var params = node.params || [];
-    if (params.length === 0) {
-      return; // 没有参数，无需检查
-    }
-
-    // 提取参数名
-    var param_names = [];
-    for (var i = 0; i < params.length; i++) {
-      var param = params[i];
-      if (param.type === 'Identifier') {
-        param_names.push(param.name);
-      }
-      // 处理解构参数
-      else if (param.type === 'ObjectPattern' && param.properties) {
-        for (var p = 0; p < param.properties.length; p++) {
-          var property = param.properties[p];
-          if (property.key && property.key.type === 'Identifier') {
-            param_names.push(property.key.name);
-          }
-        }
-      }
-    }
-
-    if (param_names.length === 0) {
-      return; // 没有有效的参数名
-    }
-
-    // 分析函数体内的标识符引用
-    var body_identifiers = this._extractIdentifiers(node.body);
-    
-    // 检查每个参数是否被正确引用
-    for (var j = 0; j < param_names.length; j++) {
-      var param_name = param_names[j];
-      var is_referenced = false;
-      var reference_errors = [];
-
-      // 检查参数是否被引用
-      for (var k = 0; k < body_identifiers.length; k++) {
-        var identifier = body_identifiers[k];
-        
-        // 检查标识符名称与参数名的相似性
-        if (this._isSimilarIdentifier(identifier.name, param_name)) {
-          if (identifier.name === param_name) {
-            // 完全匹配，正确引用
-            is_referenced = true;
-            break;
-          } else {
-            // 相似但不完全匹配，可能是拼写错误
-            reference_errors.push({
-              node: identifier.node,
-              actual_name: identifier.name,
-              expected_name: param_name
-            });
-          }
-        }
-      }
-
-      // 如果没有正确引用但有相似引用，报告错误
-      if (!is_referenced && reference_errors.length > 0) {
-        for (var m = 0; m < reference_errors.length; m++) {
-          var error = reference_errors[m];
-          
-          // 检查参数名是否符合命名规范，如果不符合，使用符合规范的名称
-          var param_name_err = this._checkParamName(param_name, null);
-          var recommended_name = param_name;
-          
-          if (param_name_err) {
-            var fix_suggestion = this._getFixSuggestion(param_name, 'param-name', param_name_err.message);
-            if (fix_suggestion && fix_suggestion.fixed_name !== param_name) {
-              recommended_name = fix_suggestion.fixed_name;
-            }
-          }
-          
-          context.report({
-            node: error.node,
-            message: "参数引用不一致：声明为 '" + param_name + "'，但引用为 '" + error.actual_name + "'，建议使用: " + recommended_name,
-            fix: function(fixer) {
-              return fixer.replaceText(error.node, recommended_name);
-            }
-          });
-        }
-      }
-    }
-  } catch (error) {
-    console.error("检查参数引用一致性时出错:", error);
-  }
-};
-
-/**
- * 提取函数体内的所有标识符
- * @param {object} node AST节点
- * @returns {array} 标识符数组
- */
-Detector.prototype._extractIdentifiers = function (node) {
-  var identifiers = [];
-  
-  if (!node) {
-    return identifiers;
-  }
-
-  var visited_nodes = new Set(); // 防止循环引用
-  var max_depth = 100; // 最大递归深度
-
-  // 递归遍历AST节点，提取标识符
-  function traverse(current_node, depth) {
-    if (!current_node || depth > max_depth) return;
-    
-    // 防止循环引用
-    if (visited_nodes.has(current_node)) return;
-    visited_nodes.add(current_node);
-
-    // 如果是标识符节点，添加到结果中
-    if (current_node.type === 'Identifier') {
-      identifiers.push({
-        name: current_node.name,
-        node: current_node
-      });
-      return;
-    }
-
-    // 遍历子节点
-    var child_nodes = [];
-    
-    switch (current_node.type) {
-      case 'FunctionExpression':
-      case 'FunctionDeclaration':
-      case 'ArrowFunctionExpression':
-        // 跳过函数定义，避免递归到参数
-        if (current_node.body) {
-          traverse(current_node.body, depth + 1);
-        }
-        break;
-      
-      case 'BlockStatement':
-        child_nodes = current_node.body || [];
-        break;
-      
-      case 'VariableDeclaration':
-        child_nodes = current_node.declarations || [];
-        break;
-      
-      case 'VariableDeclarator':
-        if (current_node.id) traverse(current_node.id, depth + 1);
-        if (current_node.init) traverse(current_node.init, depth + 1);
-        break;
-      
-      case 'ExpressionStatement':
-        if (current_node.expression) traverse(current_node.expression, depth + 1);
-        break;
-      
-      case 'CallExpression':
-        if (current_node.callee) traverse(current_node.callee, depth + 1);
-        child_nodes = current_node.arguments || [];
-        break;
-      
-      case 'MemberExpression':
-        if (current_node.object) traverse(current_node.object, depth + 1);
-        if (current_node.property) traverse(current_node.property, depth + 1);
-        break;
-      
-      case 'ReturnStatement':
-        if (current_node.argument) traverse(current_node.argument, depth + 1);
-        break;
-      
-      case 'BinaryExpression':
-      case 'LogicalExpression':
-        if (current_node.left) traverse(current_node.left, depth + 1);
-        if (current_node.right) traverse(current_node.right, depth + 1);
-        break;
-      
-      case 'UnaryExpression':
-        if (current_node.argument) traverse(current_node.argument, depth + 1);
-        break;
-      
-      case 'ConditionalExpression':
-        if (current_node.test) traverse(current_node.test, depth + 1);
-        if (current_node.consequent) traverse(current_node.consequent, depth + 1);
-        if (current_node.alternate) traverse(current_node.alternate, depth + 1);
-        break;
-      
-      case 'ArrayExpression':
-        child_nodes = current_node.elements || [];
-        break;
-      
-      case 'ObjectExpression':
-        child_nodes = current_node.properties || [];
-        break;
-      
-      case 'Property':
-        if (current_node.key) traverse(current_node.key, depth + 1);
-        if (current_node.value) traverse(current_node.value, depth + 1);
-        break;
-      
-      case 'Literal':
-        // 字面量，跳过
-        break;
-      
-      default:
-        // 对于其他节点类型，只遍历已知的AST属性，避免无限递归
-        var ast_props = ['body', 'declarations', 'expression', 'callee', 'arguments', 
-                        'object', 'property', 'argument', 'left', 'right', 'test', 
-                        'consequent', 'alternate', 'elements', 'properties', 'key', 'value'];
-        
-        for (var i = 0; i < ast_props.length; i++) {
-          var prop = ast_props[i];
-          var value = current_node[prop];
-          
-          if (Array.isArray(value)) {
-            for (var j = 0; j < value.length; j++) {
-              if (value[j] && typeof value[j] === 'object' && value[j].type) {
-                traverse(value[j], depth + 1);
-              }
-            }
-          } else if (value && typeof value === 'object' && value.type) {
-            traverse(value, depth + 1);
-          }
-        }
-        break;
-    }
-
-    // 遍历子节点数组
-    for (var k = 0; k < child_nodes.length; k++) {
-      if (child_nodes[k] && typeof child_nodes[k] === 'object' && child_nodes[k].type) {
-        traverse(child_nodes[k], depth + 1);
-      }
-    }
-  }
-
-  traverse(node, 0);
-  return identifiers;
-};
-
-/**
- * 检查两个标识符是否相似（用于检测拼写错误）
- * @param {string} actual_name 实际使用的名称
- * @param {string} expected_name 期望的名称
- * @returns {boolean} 是否相似
- */
-Detector.prototype._isSimilarIdentifier = function (actual_name, expected_name) {
-  if (actual_name === expected_name) {
-    return true;
-  }
-
-  // 检查大小写不一致的情况
-  if (actual_name.toLowerCase() === expected_name.toLowerCase()) {
-    return true;
-  }
-
-  // 检查常见的拼写错误模式
-  var common_patterns = [
-    // 下划线相关错误
-    { pattern: /_/g, replacement: '' }, // 忘记下划线
-    { pattern: /([a-z])([A-Z])/g, replacement: '$1_$2' }, // 驼峰转蛇形
-    { pattern: /_([a-z])/g, replacement: function(match, p1) { return p1.toUpperCase(); } } // 蛇形转驼峰
-  ];
-
-  for (var i = 0; i < common_patterns.length; i++) {
-    var pattern = common_patterns[i];
-    var transformed_actual = actual_name.replace(pattern.pattern, pattern.replacement);
-    var transformed_expected = expected_name.replace(pattern.pattern, pattern.replacement);
-    
-    if (transformed_actual === transformed_expected || 
-        transformed_actual.toLowerCase() === transformed_expected.toLowerCase()) {
-      return true;
-    }
-  }
-
-  // 检查编辑距离（简单的相似度检查）
-  var distance = this._levenshteinDistance(actual_name.toLowerCase(), expected_name.toLowerCase());
-  var max_length = Math.max(actual_name.length, expected_name.length);
-  var similarity = 1 - (distance / max_length);
-  
-  return similarity > 0.7; // 相似度超过70%认为相似
-};
-
-/**
- * 计算两个字符串的编辑距离（Levenshtein距离）
- * @param {string} a 字符串A
- * @param {string} b 字符串B
- * @returns {number} 编辑距离
- */
-Detector.prototype._levenshteinDistance = function (a, b) {
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-
-  var matrix = [];
-
-  // 初始化矩阵
-  for (var i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-
-  for (var j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-
-  // 计算编辑距离
-  for (i = 1; i <= b.length; i++) {
-    for (j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1, // 替换
-          matrix[i][j - 1] + 1,     // 插入
-          matrix[i - 1][j] + 1      // 删除
-        );
-      }
-    }
-  }
-
-  return matrix[b.length][a.length];
-};
-
-/**
- * 检查是否为 module.exports 中的属性
- * @param {object} node 属性节点
- * @param {object} parent_node 父节点信息
- * @returns {boolean} 是否为 module.exports 中的属性
- */
-Detector.prototype._isModuleExportsProperty = function (node, parent_node) {
-  try {
-    // 处理新的父节点信息结构（包含node和parent属性）
-    var actual_parent_node = parent_node;
-    if (parent_node && typeof parent_node === "object" && parent_node.node) {
-      actual_parent_node = parent_node.node;
-    }
-
-    if (!node || !actual_parent_node) {
-      return false;
-    }
-
-    // 检查父节点是否为 ObjectExpression（对象字面量）
-    if (actual_parent_node.type === "ObjectExpression") {
-      // 检查父节点的父节点是否为 AssignmentExpression
-      var actual_parent_parent =
-        parent_node && typeof parent_node === "object" && parent_node.parent
-          ? parent_node.parent
-          : null;
-
-      if (
-        actual_parent_parent &&
-        actual_parent_parent.type === "AssignmentExpression"
-      ) {
-        // 检查赋值表达式的左侧是否为 module.exports
-        var left = actual_parent_parent.left;
-        if (
-          left &&
-          left.type === "MemberExpression" &&
-          left.object &&
-          left.object.type === "Identifier" &&
-          left.object.name === "module" &&
-          left.property &&
-          left.property.type === "Identifier" &&
-          left.property.name === "exports"
-        ) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为 module.exports 中的属性时出错:", error);
-    return false;
-  }
-};
-
-module.exports = { Detector };
+
+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 };