mm_eslint 1.4.0 → 1.4.2

package/detector.js

@@ -9,19 +9,19 @@ class Detector {
   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': '属性值名'
+      "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": "属性值名",
     };
   }
 }
@@ -34,64 +34,119 @@ class Detector {
  */
 Detector.prototype._checkClassName = function (class_name, node) {
   try {
-    var rule = this.config.getRule('class-name');
+    var rule = this.config.getRule("class-name");
     if (!rule) {
       return null;
     }
 
     // 检查是否为忽略词
-    if (this._isIgnoredWord(class_name, 'class-name')) {
+    if (this._isIgnoredWord(class_name, "class-name")) {
       return null;
     }
 
     // 检查命名风格
-    var style_err = this._validate_naming_style(class_name, rule.styles, 'class-name');
+    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: style_err,
+        message: error_message,
+        rule_type: "class-name",
       };
     }
 
     // 检查并推荐更合适的词汇
-    var rec_err = this._checkAndRecommend(class_name, '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: rec_err,
+        message: "类名'" + class_name + "'，建议使用: " + recommended_full_name,
+        rule_type: "class-name",
       };
     }
 
     // 检查长度
-    var len_err = this._checkNameLength(class_name, rule.min, rule.max, '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: len_err,
+        message: error_message,
+        rule_type: "class-name",
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(class_name, rule.single_word_len, '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: word_err,
+        message: error_message,
+        rule_type: "class-name",
       };
     }
 
     // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(class_name, '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);
+    console.error("检测类名时出错:", error);
     return null;
   }
 };
@@ -104,72 +159,138 @@ Detector.prototype._checkClassName = function (class_name, node) {
  */
 Detector.prototype._checkMethodName = function (method_name, node) {
   try {
-    var rule = this.config.getRule('method-name');
+    var rule = this.config.getRule("method-name");
     if (!rule) {
       return null;
     }
 
     // 检查是否为忽略词（在所有检测之前）
-    if (this._isIgnoredWord(method_name, 'method-name')) {
+    if (this._isIgnoredWord(method_name, "method-name")) {
       return null;
     }
 
     // 检查命名风格（支持公开方法和私有方法）
     var style_err = null;
-    if (method_name.startsWith('_')) {
+    if (method_name.startsWith("_")) {
       // 私有方法：检查是否符合私有方法命名规范
-      style_err = this._validate_naming_style(method_name, ['_camelCase'], 'method-name');
+      style_err = this._validate_naming_style(
+        method_name,
+        ["_camelCase"],
+        "method-name",
+      );
     } else {
       // 公开方法：检查是否符合公开方法命名规范
-      style_err = this._validate_naming_style(method_name, rule.styles, 'method-name');
+      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: style_err,
+        message: error_message,
       };
     }
 
     // 检查长度
-    var len_err = this._checkNameLength(method_name, rule.min, rule.max, 'method-name');
+    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: len_err,
+        message: error_message,
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(method_name, rule.single_word_len, 'method-name');
+    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: word_err,
+        message: error_message,
       };
     }
 
     // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(method_name, 'method-name');
+    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: forbid_err,
+        message: error_message,
       };
     }
 
-    // 检查并推荐更合适的词汇
-    var recommend_err = this._checkAndRecommend(method_name, 'method-name');
-    if (recommend_err) {
+    // 如果没有错误但有推荐建议，返回优化建议
+    var smart_abbreviation = this._getSmartAbbreviation(
+      method_name,
+      "method-name",
+    );
+    if (smart_abbreviation && smart_abbreviation !== method_name) {
       return {
         node: node,
-        message: recommend_err,
+        message:
+          "方法名'" +
+          method_name +
+          "'不是行业通用名，建议使用: " +
+          smart_abbreviation,
+        fix: function (fixer) {
+          return fixer.replaceText(node, smart_abbreviation);
+        },
       };
     }
 
     return null;
   } catch (error) {
-    console.error('检测方法名时出错:', error);
+    console.error("检测方法名时出错:", error);
     return null;
   }
 };
@@ -182,67 +303,148 @@ Detector.prototype._checkMethodName = function (method_name, node) {
  */
 Detector.prototype._checkFunctionName = function (function_name, node) {
   try {
-    var rule = this.config.getRule('function-name');
+    var rule = this.config.getRule("function-name");
     if (!rule) {
       return null;
     }
 
     // 检查是否为忽略词
-    if (this._isIgnoredWord(function_name, 'function-name')) {
+    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');
+    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: style_err,
+        message: error_message,
       };
     }
 
     // 检查长度
-    var len_err = this._checkNameLength(function_name, rule.min, rule.max, 'function-name');
+    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: len_err,
+        message: error_message,
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(function_name, rule.single_word_len, 'function-name');
+    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: word_err,
+        message: error_message,
       };
     }
 
     // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(
-      function_name,
-      'function-name',
-    );
+    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: forbid_err,
+        message: error_message,
       };
     }
 
-    // 检查并推荐更合适的词汇
-    var recommend_err = this._checkAndRecommend(function_name, 'function-name');
-    if (recommend_err) {
+    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
+    var recommend_info = this._checkAndRecommend(
+      function_name,
+      "function-name",
+    );
+    if (recommend_info) {
+      // 如果有推荐建议，提示可以使用更简洁的词汇
       return {
         node: node,
-        message: recommend_err,
+        message:
+          "函数名'" +
+          function_name +
+          "'建议使用: " +
+          recommend_info.recommended_name,
       };
     }
 
     return null;
   } catch (error) {
-    console.error('检测函数名时出错:', error);
+    console.error("检测函数名时出错:", error);
     return null;
   }
 };
@@ -255,18 +457,22 @@ Detector.prototype._checkFunctionName = function (function_name, node) {
  */
 Detector.prototype._checkVariableName = function (variable_name, node) {
   try {
-    var rule = this.config.getRule('variable-name');
+    var rule = this.config.getRule("variable-name");
     if (!rule) {
       return null;
     }
 
     // 检查是否为忽略词
-    if (this._isIgnoredWord(variable_name, 'variable-name')) {
+    if (this._isIgnoredWord(variable_name, "variable-name")) {
       return null;
     }
 
     // 检查命名风格
-    var style_err = this._validate_naming_style(variable_name, rule.styles, 'variable-name');
+    var style_err = this._validate_naming_style(
+      variable_name,
+      rule.styles,
+      "variable-name",
+    );
     if (style_err) {
       return {
         node: node,
@@ -275,28 +481,59 @@ Detector.prototype._checkVariableName = function (variable_name, node) {
     }
 
     // 检查长度
-    var len_err = this._checkNameLength(variable_name, rule.min, rule.max, 'variable-name');
+    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: len_err,
+        message: error_message,
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(variable_name, rule.single_word_len, 'variable-name');
+    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: word_err,
+        message: error_message,
       };
     }
 
     // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(
-      variable_name,
-      'variable-name',
-    );
+    var forbid_err = this._checkForbiddenWords(variable_name, "variable-name");
     if (forbid_err) {
       return {
         node: node,
@@ -306,7 +543,7 @@ Detector.prototype._checkVariableName = function (variable_name, node) {
 
     return null;
   } catch (error) {
-    console.error('检测变量名时出错:', error);
+    console.error("检测变量名时出错:", error);
     return null;
   }
 };
@@ -319,55 +556,111 @@ Detector.prototype._checkVariableName = function (variable_name, node) {
  */
 Detector.prototype._checkParamName = function (param_name, node) {
   try {
-    var rule = this.config.getRule('param-name');
+    var rule = this.config.getRule("param-name");
     if (!rule) {
       return null;
     }
 
     // 检查是否为忽略词
-    if (this._isIgnoredWord(param_name, 'param-name')) {
+    if (this._isIgnoredWord(param_name, "param-name")) {
       return null;
     }
 
     // 检查命名风格
-    var style_err = this._validate_naming_style(param_name, rule.styles, 'param-name');
+    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: style_err,
+        message: error_message,
       };
     }
 
     // 检查长度
-    var len_err = this._checkNameLength(param_name, rule.min, rule.max, 'param-name');
+    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: len_err,
+        message: error_message,
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(param_name, rule.single_word_len, 'param-name');
+    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: word_err,
+        message: error_message,
       };
     }
 
     // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(param_name, 'param-name');
+    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: forbid_err,
+        message: error_message,
       };
     }
 
     return null;
   } catch (error) {
-    console.error('检测参数名时出错:', error);
+    console.error("检测参数名时出错:", error);
     return null;
   }
 };
@@ -379,101 +672,207 @@ Detector.prototype._checkParamName = function (param_name, node) {
  * @param {object} val_node 值节点（用于识别基础值）
  * @returns {object|null} 错误信息或null
  */
-Detector.prototype._checkConstantName = function (constant_name, node, val_node) {
+Detector.prototype._checkConstantName = function (
+  constant_name,
+  node,
+  val_node,
+) {
   try {
-    var rule = this.config.getRule('constant-name');
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, 'constant-name')) {
-      return null;
-    }
-
     // 检查是否为解构导入（从模块导入的变量）
     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声明，因为它不是真正的常量`
+        message: `变量'${constant_name}'应该使用let而不是const声明，因为它不是真正的常量`,
       };
     }
 
-    // 检查是否为复杂类型（方法、函数、实例等）
-    var is_complex_type = this._isComplexType(val_node);
+    // 根据值类型确定应该应用的命名规则
+    var rule_type = "constant-name"; // 默认使用常量命名规则
+    var allowed_styles = [];
 
-    // 如果是复杂类型，则不进行常量检测
-    if (is_complex_type) {
+    // 检查是否为函数表达式或箭头函数
+    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 is_base_value = this._isBaseValue(val_node);
+    // 获取对应的命名规则
+    // 将属性规则类型映射到对应的基础规则类型（用于获取规则配置）
+    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 (!is_base_value) {
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(constant_name, rule_type)) {
       return null;
     }
 
     // 检查命名风格
-    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    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: style_err,
+        message: error_message,
+        rule_type: rule_type, // 返回正确的规则类型
       };
     }
 
     // 检查长度
-    var len_err = this._checkNameLength(constant_name, rule.min, rule.max, 'constant-name');
+    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: len_err,
+        message: error_message,
+        rule_type: rule_type, // 返回正确的规则类型
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(constant_name, rule.single_word_len, 'constant-name');
+    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, 'constant-name');
+    var forbid_err = this._checkForbiddenWords(constant_name, rule_type);
     if (forbid_err) {
       return {
         node: node,
         message: forbid_err,
+        rule_type: rule_type, // 返回正确的规则类型
       };
     }
 
-    // 检查并推荐更合适的词汇
-    var rec_err = this._checkAndRecommend(constant_name, 'constant-name');
-    if (rec_err) {
+    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
+    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: rec_err,
+        message:
+          name_type_text +
+          "'" +
+          constant_name +
+          "'长度过长，最大长度为20字符，建议使用: " +
+          recommend_info.recommended_name,
+        rule_type: rule_type, // 返回正确的规则类型
       };
     }
 
     return null;
   } catch (error) {
-    console.error('检测常量名时出错:', error);
+    console.error("检测常量名时出错:", error);
     return null;
   }
 };
@@ -498,11 +897,11 @@ Detector.prototype._validate_naming_style = function (name, styles, name_type) {
     }
   }
 
-  var style_names = styles.join('或');
+  var style_names = styles.join("或");
 
-  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+  var name_type_desc = this.config.name_type_map[name_type] || "名称";
 
-  return name_type_desc + '\'' + name + '\'不符合' + style_names + '命名风格';
+  return name_type_desc + "'" + name + "'不符合" + style_names + "命名风格";
 };
 
 /**
@@ -514,17 +913,17 @@ Detector.prototype._validate_naming_style = function (name, styles, name_type) {
  */
 Detector.prototype._checkNameLength = function (name, min, max, name_type) {
   if (!name) {
-    return '名称不能为空';
+    return "名称不能为空";
   }
 
-  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+  var name_type_desc = this.config.name_type_map[name_type] || "名称";
   var len = name.length;
   if (len < min) {
-    return name_type_desc + '\'' + name + '\'长度过短，最小长度为' + min + '字符';
+    return name_type_desc + "'" + name + "'长度过短，最小长度为" + min + "字符";
   }
 
   if (len > max) {
-    return name_type_desc + '\'' + name + '\'长度过长，最大长度为' + max + '字符';
+    return name_type_desc + "'" + name + "'长度过长，最大长度为" + max + "字符";
   }
 
   return null;
@@ -541,13 +940,13 @@ Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
     return null;
   }
 
-  var name_type_desc = this.config.name_type_map[name_type] || '名称';
-  
+  var name_type_desc = this.config.name_type_map[name_type] || "名称";
+
   // 处理私有标识符（开头的下划线）
   var processed_name = name;
   var has_private_prefix = false;
 
-  if (name.startsWith('_')) {
+  if (name.startsWith("_")) {
     has_private_prefix = true;
     processed_name = name.substring(1); // 去掉开头的下划线
   }
@@ -555,10 +954,10 @@ Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
   // 分割单词（根据命名风格）
   var words = [];
 
-  if (processed_name.includes('_')) {
-    words = processed_name.split('_');
-  } else if (processed_name.includes('-')) {
-    words = processed_name.split('-');
+  if (processed_name.includes("_")) {
+    words = processed_name.split("_");
+  } else if (processed_name.includes("-")) {
+    words = processed_name.split("-");
   } else {
     // 驼峰命名法分割（保持原词大小写）
     words = processed_name.split(/(?=[A-Z])/);
@@ -566,11 +965,11 @@ Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
 
   // 如果存在私有标识符，添加空字符串表示私有标识符（不检查长度）
   if (has_private_prefix) {
-    words.unshift('_');
+    words.unshift("_");
   }
 
   // 过滤空字符串
-  words = words.filter(function(word) {
+  words = words.filter(function (word) {
     return word && word.length > 0;
   });
 
@@ -582,27 +981,27 @@ Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
   for (var i = 0; i < words.length; i++) {
     var word = words[i];
     // 跳过空字符串和私有标识符（单个下划线）
-    if (!word || word === '_') {
+    if (!word || word === "_") {
       continue;
     }
 
     if (word.length > max_word_len) {
-      // 生成推荐命名
-      var recommended_name = this._generateRecommendedName(name, word, name_type);
-      var recommendation_text = '';
-      if (recommended_name) {
-        recommendation_text = '，推荐名为\'' + recommended_name + '\'';
+      // 使用智能缩写生成推荐名称
+      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
       );
     }
@@ -627,7 +1026,7 @@ Detector.prototype._checkForbiddenWords = function (name, name_type) {
     return null;
   }
 
-  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+  var name_type_desc = this.config.name_type_map[name_type] || "名称";
   var name_lower = name.toLowerCase();
 
   // 如果名称本身就是禁止词汇（即单个单词），则允许使用
@@ -640,23 +1039,45 @@ Detector.prototype._checkForbiddenWords = function (name, name_type) {
 
   // 按单词边界分割名称
   var words = this._splitNameIntoWords(name_lower);
-  
+
   // 检查每个单词是否在禁止词汇列表中
+  var found_forbidden_words = [];
+  
   for (var i = 0; i < words.length; i++) {
     var word = words[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) {
-        return name_type_desc + '\'' + name + '\'包含禁止拼接词\'' + 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;
 };
 
@@ -669,22 +1090,22 @@ Detector.prototype._splitNameIntoWords = function (name) {
   if (!name) {
     return [];
   }
-  
+
   var words = [];
   var processed_name = name;
   var has_private_prefix = false;
 
   // 处理私有标识符（开头的下划线）
-  if (name.startsWith('_')) {
+  if (name.startsWith("_")) {
     has_private_prefix = true;
     processed_name = name.substring(1); // 去掉开头的下划线
   }
 
   // 根据命名风格分割单词
-  if (processed_name.includes('_')) {
-    words = processed_name.split('_');
-  } else if (processed_name.includes('-')) {
-    words = processed_name.split('-');
+  if (processed_name.includes("_")) {
+    words = processed_name.split("_");
+  } else if (processed_name.includes("-")) {
+    words = processed_name.split("-");
   } else {
     // 驼峰命名法分割（保持原词大小写）
     words = processed_name.split(/(?=[A-Z])/);
@@ -692,11 +1113,11 @@ Detector.prototype._splitNameIntoWords = function (name) {
 
   // 如果存在私有标识符，添加下划线作为第一个单词
   if (has_private_prefix) {
-    words.unshift('_');
+    words.unshift("_");
   }
 
   // 过滤空字符串
-  words = words.filter(function(word) {
+  words = words.filter(function (word) {
     return word && word.length > 0;
   });
 
@@ -711,48 +1132,101 @@ Detector.prototype._splitNameIntoWords = function (name) {
  */
 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 (!parent_node || parent_node.type !== 'ObjectExpression') {
+    if (!actual_parent_node || actual_parent_node.type !== "ObjectExpression") {
       return false;
     }
 
-    // 检查对象字面量是否作为方法调用的参数
-    var grandparent = parent_node.parent;
-    if (!grandparent || grandparent.type !== 'CallExpression') {
+    // 递归查找调用表达式（处理嵌套对象的情况）
+    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 = grandparent.callee;
+    var callee = call_expression.callee;
     if (!callee) {
       return false;
     }
 
     // 如果是成员表达式（如 chokidar.watch），则认为是第三方库调用
-    if (callee.type === 'MemberExpression') {
+    if (callee.type === "MemberExpression") {
+      // 检查成员表达式的对象是否为模块导入变量
+      var is_module_import = this._isModuleImportVariable(callee.object);
+      if (is_module_import) {
+        return true;
+      }
+
+      // 对于其他成员表达式，也认为是第三方库调用（保守策略）
       return true;
     }
 
     // 如果是标识符，检查是否是常见的第三方库函数名
-    if (callee.type === 'Identifier') {
+    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'
+        "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);
+    console.error("检查第三方库配置参数时出错:", error);
     return false;
   }
 };
@@ -766,59 +1240,125 @@ Detector.prototype._isThirdPartyConfigProperty = function (node, parent_node) {
  */
 Detector.prototype._getPropType = function (val_node, prop_name, parent_node) {
   if (!val_node) {
-    return 'undefined_value'; // 未赋值类型
+    return "undefined_value"; // 未赋值类型
   }
 
   // 检查是否为null值
-  if (val_node.type === 'NullLiteral') {
-    return 'null_value'; // null值类型
+  if (val_node.type === "NullLiteral") {
+    return "null_value"; // null值类型
   }
 
   // 检查是否为对象方法（在对象字面量中的函数）
   if (
     val_node &&
-    (val_node.type === 'FunctionExpression' ||
-      val_node.type === 'ArrowFunctionExpression')
+    (val_node.type === "FunctionExpression" ||
+      val_node.type === "ArrowFunctionExpression")
   ) {
-    return 'method'; // 对象方法类型
+    return "method"; // 对象方法类型
   }
 
   // 检查是否为类引用（属性类）
   if (
-    val_node.type === 'Identifier' &&
+    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'];
+    var special_globals = [
+      "__dirname",
+      "__filename",
+      "process",
+      "console",
+      "module",
+      "exports",
+      "require",
+      "global",
+    ];
     if (special_globals.includes(val_node.name)) {
-      return 'value'; // 特殊全局变量应该识别为属性值
+      return "value"; // 特殊全局变量应该识别为属性值
     }
-    
+
     // 检查是否是类名引用（通常类名使用PascalCase）
-    return 'class'; // 属性类类型
+    return "class"; // 属性类类型
   }
 
   // 检查是否为类实例（new表达式）
-  if (val_node.type === 'NewExpression') {
-    return 'instance_class'; // 属性实例类类型
+  if (val_node.type === "NewExpression") {
+    return "instance_class"; // 属性实例类类型
   }
 
   // 检查是否为函数调用（可能返回实例）
-  if (val_node.type === 'CallExpression') {
+  if (val_node.type === "CallExpression") {
     // 检查是否调用的是构造函数
     if (
       val_node.callee &&
-      val_node.callee.type === 'Identifier' &&
+      val_node.callee.type === "Identifier" &&
       val_node.callee.name &&
       val_node.callee.name[0] === val_node.callee.name[0].toUpperCase()
     ) {
-      return 'instance_class'; // 属性实例类类型
+      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'; // 默认值类型
+    return "value"; // 普通对象
   }
 
-  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";
 };
 
 /**
@@ -837,131 +1377,195 @@ Detector.prototype._checkPropertyName = function (
 ) {
   try {
     // 检查是否为解构导入中的属性
-    var is_destructured_import = this._isDestructuredImportProperty(node, parent_node);
-    
+    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);
-    
+    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 = '';
+    var rule_type = "";
 
     // 根据属性类型选择对应的规则
     // 对于null值和未赋值属性，直接跳过命名规范检测
-    if (prop_type === 'null_value' || prop_type === 'undefined_value') {
+    if (prop_type === "null_value" || prop_type === "undefined_value") {
       return null; // 不进行命名规范检测
     }
 
     switch (prop_type) {
-      case 'class':
-        rule_type = 'property-class-name';
+      case "class":
+        rule_type = "property-class-name";
         break;
-      case 'instance_class':
-        rule_type = 'property-instance-class-name';
+      case "instance_class":
+        rule_type = "property-instance-class-name";
         break;
-      case 'method':
-        rule_type = 'property-method-name';
+      case "method":
+        rule_type = "property-method-name";
         break;
-      case 'value':
+      case "value":
       default:
-        rule_type = 'property-value-name';
+        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(rule_type);
+    var ignored_words = this.config.getIgnoredWords(base_rule_type);
     if (ignored_words && ignored_words.includes(prop_name)) {
       return null; // 忽略词不进行命名规范检测
     }
 
-    var rule = this.config.getRule(rule_type);
+    var rule = this.config.getRule(base_rule_type);
     if (!rule) {
       return null;
     }
 
-    // 检查命名风格
+    // 首先检查命名风格
     var style_err = null;
-    
-    if (rule_type === 'property-value-name') {
-      // 对于属性值名，支持私有变量命名规范（_snake_case）、变量命名规范（snake_case）或常量命名规范（UPPER_SNAKE_CASE）
-      var private_style_err = this._validate_naming_style(prop_name, ['_snake_case'], rule_type);
-      var variable_style_err = this._validate_naming_style(prop_name, ['snake_case'], rule_type);
-      var constant_style_err = this._validate_naming_style(prop_name, ['UPPER_SNAKE_CASE'], rule_type);
-      
-      // 只有当所有风格检查都失败时才报错
-      if (private_style_err && variable_style_err && constant_style_err) {
-        style_err = '属性值名\'' + prop_name + '\'不符合_snake_case、snake_case或UPPER_SNAKE_CASE命名风格';
-      }
-    } else if (rule_type === 'property-method-name') {
-      // 属性方法：支持公开方法（camelCase）和私有方法（_camelCase）
-      if (prop_name.startsWith('_')) {
-        // 私有方法：检查是否符合私有方法命名规范
-        style_err = this._validate_naming_style(prop_name, ['_camelCase'], rule_type);
-      } else {
-        // 公开方法：检查是否符合公开方法命名规范
-        style_err = this._validate_naming_style(prop_name, rule.styles, rule_type);
-      }
-    } else if (rule_type === 'property-instance-class-name') {
-      // 属性实例类：支持公开实例类（camelCase）和私有实例类（_camelCase）
-      if (prop_name.startsWith('_')) {
-        // 私有实例类：检查是否符合私有实例类命名规范
-        style_err = this._validate_naming_style(prop_name, ['_camelCase'], rule_type);
-      } else {
-        // 公开实例类：检查是否符合公开实例类命名规范
-        style_err = this._validate_naming_style(prop_name, rule.styles, rule_type);
-      }
+
+    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);
+      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);
+    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: len_err,
+        message: error_message,
+        rule_type: rule_type, // 添加规则类型信息
       };
     }
 
     // 检查单词长度
-    var word_err = this._checkWordLength(prop_name, rule.single_word_len, rule_type);
+    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: word_err,
+        message: error_message,
+        rule_type: rule_type, // 添加规则类型信息
       };
     }
 
     // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(prop_name, 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);
+    console.error("检测属性名时出错:", error);
     return null;
   }
 };
@@ -980,8 +1584,10 @@ Detector.prototype._checkAndRecommend = function (name, name_type) {
     }
 
     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();
 
-    var name_type_desc = this.config.name_type_map[name_type] || '名称';
     // 检查每个推荐词映射
     for (var rec_word in rec_words) {
       if (rec_words.hasOwnProperty(rec_word)) {
@@ -990,8 +1596,32 @@ Detector.prototype._checkAndRecommend = function (name, name_type) {
         // 检查名称是否包含任何一个原词
         for (var i = 0; i < original_words.length; i++) {
           var original_word = original_words[i].toLowerCase();
-          if (name_lower.includes(original_word)) {
-            return name_type_desc + '建议使用\'' + rec_word + '\'替代\'' + original_words[i] + '\'以获得更短的命名';
+
+          // 检查名称（去除私有前缀后）是否包含原词
+          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,
+            };
           }
         }
       }
@@ -999,7 +1629,7 @@ Detector.prototype._checkAndRecommend = function (name, name_type) {
 
     return null;
   } catch (error) {
-    console.error('检查并推荐更合适的词汇时出错:', error);
+    console.error("检查并推荐更合适的词汇时出错:", error);
     return null;
   }
 };
@@ -1019,17 +1649,17 @@ Detector.prototype._isBaseValue = function (val_node) {
     var is_base_value = false;
 
     switch (val_node.type) {
-      case 'Literal': // 字面量：数字、字符串、布尔值
+      case "Literal": // 字面量：数字、字符串、布尔值
         is_base_value = true;
         break;
-      case 'ArrayExpression': // 数组字面量
+      case "ArrayExpression": // 数组字面量
         is_base_value = true;
         break;
-      case 'ObjectExpression': // 对象字面量
+      case "ObjectExpression": // 对象字面量
         is_base_value = true;
         break;
-      case 'UnaryExpression': // 一元表达式（如 -1, +100）
-        if (val_node.operator === '-' || val_node.operator === '+') {
+      case "UnaryExpression": // 一元表达式（如 -1, +100）
+        if (val_node.operator === "-" || val_node.operator === "+") {
           is_base_value = true;
         }
         break;
@@ -1039,7 +1669,7 @@ Detector.prototype._isBaseValue = function (val_node) {
 
     return is_base_value;
   } catch (error) {
-    console.error('检查值是否为基础值类型时出错:', error);
+    console.error("检查值是否为基础值类型时出错:", error);
     return false;
   }
 };
@@ -1056,22 +1686,51 @@ Detector.prototype._shouldUseLetInsteadOfConst = function (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') {
+    if (node.parent && node.parent.type === "VariableDeclarator") {
       var declarator = node.parent;
-      if (declarator.id && (declarator.id.type === 'ObjectPattern' || declarator.id.type === 'ArrayPattern')) {
+      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;
+    }
 
-    // 如果是解构赋值且右侧是复杂类型，建议使用let
-    return is_destructuring && is_complex_type;
+    return should_use_let;
   } catch (error) {
-    console.error('检查是否应该使用let时出错:', error);
+    console.error("检查是否应该使用let时出错:", error);
     return false;
   }
 };
@@ -1091,15 +1750,15 @@ Detector.prototype._isComplexType = function (val_node) {
     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': // 模板字符串
+      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:
@@ -1108,17 +1767,115 @@ Detector.prototype._isComplexType = function (val_node) {
 
     return is_complex_type;
   } catch (error) {
-    console.error('检查值是否为复杂类型时出错:', error);
+    console.error("检查值是否为复杂类型时出错:", error);
     return false;
   }
 };
 
 /**
- * 检查是否为解构导入
- * @param {object} node AST节点
- * @returns {boolean} 是否为解构导入
+ * 检查是否为模块导入（需要排除const检测的情况）
+ * @param {object} node 变量声明节点
+ * @param {object} val_node 值节点
+ * @returns {boolean} 是否为模块导入
  */
-Detector.prototype._isDestructuredImport = function (node) {
+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;
@@ -1128,56 +1885,63 @@ Detector.prototype._isDestructuredImport = function (node) {
     var is_destructured = false;
 
     // 情况1：节点是Property.key（解构赋值中的属性键）
-    if (node.parent.type === 'Property' && node.parent.key === node) {
+    if (node.parent.type === "Property" && node.parent.key === node) {
       var property = node.parent;
-      
+
       // 检查Property的父节点是否为ObjectPattern
-      if (property.parent && property.parent.type === 'ObjectPattern') {
+      if (property.parent && property.parent.type === "ObjectPattern") {
         var object_pattern = property.parent;
-        
+
         // 检查ObjectPattern的父节点是否为VariableDeclarator
-        if (object_pattern.parent && object_pattern.parent.type === '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') {
+            if (
+              init_type === "CallExpression" &&
+              declarator.init.callee &&
+              declarator.init.callee.name === "require"
+            ) {
               is_destructured = true;
             }
-            
+
             // 如果是ImportDeclaration（ES6导入）
-            if (init_type === 'ImportExpression') {
+            if (init_type === "ImportExpression") {
               is_destructured = true;
             }
           }
         }
       }
     }
-    
+
     // 情况2：节点是VariableDeclarator（简单变量声明）
-    else if (node.parent.type === 'VariableDeclarator') {
+    else if (node.parent.type === "VariableDeclarator") {
       var declarator = node.parent;
-      
+
       // 检查是否为解构模式（ObjectPattern或ArrayPattern）
-      if (declarator.id && declarator.id.type === 'ObjectPattern') {
+      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') {
+          if (
+            init_type === "CallExpression" &&
+            declarator.init.callee &&
+            declarator.init.callee.name === "require"
+          ) {
             is_destructured = true;
           }
-          
+
           // 如果是ImportDeclaration（ES6导入）
-          if (init_type === 'ImportExpression') {
+          if (init_type === "ImportExpression") {
             is_destructured = true;
           }
         }
@@ -1186,7 +1950,7 @@ Detector.prototype._isDestructuredImport = function (node) {
 
     return is_destructured;
   } catch (error) {
-    console.error('检查是否为解构导入时出错:', error);
+    console.error("检查是否为解构导入时出错:", error);
     return false;
   }
 };
@@ -1197,31 +1961,137 @@ Detector.prototype._isDestructuredImport = function (node) {
  * @param {object} parent_node 父节点
  * @returns {boolean} 是否为解构导入中的属性
  */
-Detector.prototype._isDestructuredImportProperty = function (node, parent_node) {
+Detector.prototype._isDestructuredImportProperty = function (
+  node,
+  parent_node,
+) {
   try {
-    if (!node || !parent_node) {
+    // 处理新的父节点信息结构（包含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 (parent_node.type === 'ObjectPattern') {
+    if (actual_parent_node.type === "ObjectPattern") {
       // 检查父节点的父节点是否为VariableDeclarator
-      if (parent_node.parent && parent_node.parent.type === 'VariableDeclarator') {
-        var declarator = parent_node.parent;
-        
+      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') {
+          if (
+            init_type === "CallExpression" &&
+            declarator.init.callee &&
+            declarator.init.callee.name === "require"
+          ) {
             return true;
           }
-          
+
           // 如果是ImportDeclaration（ES6导入）
-          if (init_type === 'ImportExpression') {
+          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;
           }
         }
@@ -1230,7 +2100,7 @@ Detector.prototype._isDestructuredImportProperty = function (node, parent_node)
 
     return false;
   } catch (error) {
-    console.error('检查是否为解构导入中的属性时出错:', error);
+    console.error("检查是否为函数赋值时出错:", error);
     return false;
   }
 };
@@ -1242,16 +2112,20 @@ Detector.prototype._isDestructuredImportProperty = function (node, parent_node)
  */
 Detector.prototype._isConstantNameValid = function (constant_name) {
   try {
-    var rule = this.config.getRule('constant-name');
+    var rule = this.config.getRule("constant-name");
     if (!rule) {
       return false;
     }
 
     // 检查命名风格
-    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    var style_err = this._validate_naming_style(
+      constant_name,
+      rule.styles,
+      "constant-name",
+    );
     return !style_err;
   } catch (error) {
-    console.error('检查常量名是否符合规范时出错:', error);
+    console.error("检查常量名是否符合规范时出错:", error);
     return false;
   }
 };
@@ -1277,8 +2151,8 @@ Detector.prototype._isIgnoredWord = function (name, name_type) {
     }
 
     return false;
-  } catch (error) { 
-    console.error('检查是否为忽略词时出错:', error);
+  } catch (error) {
+    console.error("检查是否为忽略词时出错:", error);
     return false;
   }
 };
@@ -1290,7 +2164,11 @@ Detector.prototype._isIgnoredWord = function (name, name_type) {
  * @param {string} name_type 名称类型
  * @returns {string|null} 推荐命名或null
  */
-Detector.prototype._generateRecommendedName = function (original_name, long_word, name_type) {
+Detector.prototype._generateRecommendedName = function (
+  original_name,
+  long_word,
+  name_type,
+) {
   try {
     // 获取推荐词映射
     var recommended_words = this.config.getRecommendedWords(name_type);
@@ -1299,18 +2177,26 @@ Detector.prototype._generateRecommendedName = function (original_name, long_word
     }
 
     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 = original_name.replace(long_word, short_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;
           }
         }
@@ -1319,85 +2205,1434 @@ Detector.prototype._generateRecommendedName = function (original_name, long_word
 
     return null;
   } catch (error) {
-    console.error('生成推荐命名时出错:', error);
+    console.error("生成推荐命名时出错:", error);
     return null;
   }
 };
 
 /**
- * 检测解构赋值中的常量名
- * @param {string} constant_name 常量名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
+ * 转换命名风格
+ * @param {string} name 原始名称
+ * @param {string} target_style 目标命名风格
+ * @param {string} name_type 名称类型
+ * @returns {string} 转换后的名称
  */
-Detector.prototype._checkConstantNameForDestructuring = function (constant_name, node) {
+Detector.prototype._convertNamingStyle = function (
+  name,
+  target_style,
+  name_type,
+) {
   try {
-    var rule = this.config.getRule('constant-name');
-    if (!rule) {
-      return null;
+    if (!name || !target_style) {
+      return name;
     }
 
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, 'constant-name')) {
-      return null;
+    // 处理私有标识符
+    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 is_destructured_import = this._isDestructuredImport(node);
-    
-    // 如果是解构导入，则不进行常量检测
-    if (is_destructured_import) {
+    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;
     }
 
-    // 对于解构赋值，直接提示使用let而不是const
-    // 因为解构赋值通常不是真正的常量
-    return {
-      node: node,
-      message: `变量'${constant_name}'应该使用let而不是const声明，因为它不是真正的常量`
-    };
+    // 根据名称类型智能选择目标风格
+    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 rec_err = this._checkAndRecommend(constant_name, 'constant-name');
-    if (rec_err) {
-      return {
-        node: node,
-        message: rec_err,
-      };
+        // 验证建议的名称是否有效
+        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);
+        }
+      }
     }
 
-    // 检查长度
-    var len_err = this._checkNameLength(constant_name, rule.min, rule.max, 'constant-name');
-    if (len_err) {
-      return {
-        node: node,
-        message: len_err,
-      };
+    // 检查是否需要智能缩写（长度过长的问题）
+    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 word_err = this._checkWordLength(constant_name, rule.single_word_len, 'constant-name');
-    if (word_err) {
-      return {
-        node: node,
-        message: word_err,
-      };
+    // 检查修复后的名称是否仍然有错误
+    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;
+        }
+      }
     }
 
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(constant_name, 'constant-name');
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-      };
+    // 如果名称长度仍然过长，且错误消息中没有建议名称，进行智能缩写处理
+    if (
+      error_message &&
+      error_message.includes("长度过长") &&
+      !error_message.includes("建议使用:")
+    ) {
+      fixed_name = this._getSmartAbbreviation(name, name_type);
     }
 
-    return null;
+    return {
+      fixed_name: fixed_name,
+      target_style: target_style,
+    };
   } catch (error) {
-    console.error('检测解构赋值常量名时出错:', 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, "variable-name");
+    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 };