mm_eslint 1.4.3 → 1.4.5

package/detector.js

@@ -1,5 +1,10 @@
+const { Validator } = require('./validator');
+const { Corrector } = require('./corrector');
+const { Tip } = require('./tip');
+
 /**
- * 命名规范检测器类
+ * 类型检测器类
+ * 负责根据AST节点推断命名类型
  */
 class Detector {
   /**
@@ -7,3658 +12,1280 @@ class Detector {
    * @param {object} config 配置对象
    */
   constructor(config) {
-    // 直接将传入的配置对象赋值，确保原型方法不被丢失
     this.config = config;
+    this.validator = new Validator(config);
+    this.corrector = new Corrector(config);
+    this.tip = new Tip(config);
+  }
 
-    // 添加命名类型的中文描述
-    this.config.name_type_map = {
-      "class-name": "类名",
-      "function-name": "函数名",
-      "method-name": "方法名",
-      "variable-name": "变量名",
-      "param-name": "参数名",
-      "constant-name": "常量名",
-      "property-class-name": "属性类名",
-      "property-instance-class-name": "属性实例类名",
-      "property-method-name": "属性方法名",
-      "property-value-name": "属性值名",
-    };
+  /**
+   * 检测类声明类型
+   * @param {object} node AST节点
+   * @returns {string} 类型名称
+   */
+  detectClassType(node) {
+    if (node.type === 'ClassDeclaration') {
+      return 'class';
+    }
+
+    if (node.type === 'ClassExpression') {
+      return 'class';
+    }
+
+    if (node.type === 'VariableDeclaration' &&
+      node.declarations &&
+      node.declarations.length > 0 &&
+      node.declarations[0].init &&
+      node.declarations[0].init.type === 'ClassExpression') {
+      return 'class';
+    }
+
+    if (node.type === 'AssignmentExpression' && node.right && node.right.type === 'ClassExpression') {
+      return 'class';
+    }
+
+    if (node.type === 'Property' && node.value && node.value.type === 'ClassExpression') {
+      return 'property-class';
+    }
+
+    // 处理 module.exports = class user_manager {} 这种形式
+    if (node.type === 'AssignmentExpression' &&
+      node.left &&
+      node.left.type === 'MemberExpression' &&
+      node.left.object &&
+      node.left.object.type === 'Identifier' &&
+      node.left.object.name === 'module' &&
+      node.left.property &&
+      node.left.property.type === 'Identifier' &&
+      node.left.property.name === 'exports' &&
+      node.right &&
+      node.right.type === 'ClassExpression') {
+      return 'class';
+    }
+
+    // 处理 module.exports = { Admin: Admin, AdminManager } 这种形式的引用
+    if ((node.type === 'Property' || node.type === 'ObjectProperty') && node.key && node.key.type === 'Identifier') {
+      // 检查是否在导出语句的上下文中
+      var parent = node.parent;
+      if (parent && parent.type === 'ObjectExpression') {
+        var grand_parent = parent.parent;
+        if (grand_parent && grand_parent.type === 'AssignmentExpression' &&
+          grand_parent.left && grand_parent.left.type === 'MemberExpression' &&
+          grand_parent.left.object && grand_parent.left.object.type === 'Identifier' &&
+          grand_parent.left.object.name === 'module' &&
+          grand_parent.left.property && grand_parent.left.property.type === 'Identifier' &&
+          grand_parent.left.property.name === 'exports') {
+          
+          // 通用类型溯源：对于导出语句中的属性，溯源其引用的类型
+          var traced_type = this._traceReferenceType(node);
+          if (traced_type) {
+            return traced_type;
+          }
+          
+          // 如果无法溯源到具体类型，返回null让其他检测器处理
+          return null;
+        }
+      }
+    }
+
+    return null;
   }
-}
 
-/**
- * 检测类名
- * @param {string} class_name 类名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkClassName = function (class_name, node) {
-  try {
-    var rule = this.config.getRule("class-name");
-    if (!rule) {
-      return null;
+  /**
+   * 检测类实例类型
+   * @param {object} node AST节点
+   * @returns {string} 类型名称
+   */
+  detectClassInstanceType(node) {
+    // VariableDeclaration 中的 new 表达式
+    if (node.type === 'VariableDeclaration') {
+      if (node.declarations && node.declarations.length > 0) {
+        var decl = node.declarations[0];
+        if (decl.init && decl.init.type === 'NewExpression') {
+          return 'class-instance';
+        }
+      }
     }
 
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(class_name, "class-name")) {
-      return null;
+    if (node.type === 'Property' && node.value && node.value.type === 'NewExpression') {
+      return 'property-class-instance';
     }
 
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      class_name,
-      rule.styles,
-      "class-name",
-    );
-    if (style_err) {
-      // 如果有推荐建议，在风格错误消息后附加推荐
-      var smart_abbreviation = this._getSmartAbbreviation(
-        class_name,
-        "class-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== class_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查并推荐更合适的词汇
-    var rec_err = this._checkAndRecommend(class_name, "class-name");
-    if (rec_err) {
-      // 生成完整的建议名称
-      var recommended_full_name = class_name.replace(
-        new RegExp(rec_err.original_word, "i"),
-        rec_err.recommended_word,
-      );
-
-      return {
-        node: node,
-        message: "类名'" + class_name + "'，建议使用: " + recommended_full_name,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      class_name,
-      rule.min,
-      rule.max,
-      "class-name",
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        class_name,
-        "class-name",
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== class_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
+    if (node.type === 'AssignmentExpression' && node.right && node.right.type === 'NewExpression') {
+      return 'property-class-instance';
+    }
+
+    if (node.type === 'PropertyDefinition' && node.key && node.value && node.value.type === 'NewExpression') {
+      // 判断是否是私有字段
+      if (node.key.type === 'PrivateIdentifier') {
+        return 'private-class-instance';
       }
-      return {
-        node: node,
-        message: error_message,
-        rule_type: "class-name",
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      class_name,
-      rule.single_word_len,
-      "class-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          class_name,
-          "class-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== class_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
+      return node.static ? 'static-class-instance' : 'property-class-instance';
+    }
+
+    // 正则表达式字面量视为类实例
+    if (node.type === 'VariableDeclaration') {
+      if (node.declarations && node.declarations.length > 0) {
+        var decl = node.declarations[0];
+        if (decl.init && decl.init.type === 'Literal' && decl.init.regex) {
+          return 'class-instance';
         }
       }
-
-      return {
-        node: node,
-        message: error_message,
-        rule_type: "class-name",
-      };
     }
 
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(class_name, "class-name");
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-        rule_type: "class-name",
-      };
+    if (node.type === 'Property' && node.value && node.value.type === 'Literal' && node.value.regex) {
+      return 'property-class-instance';
     }
 
-    return null;
-  } catch (error) {
-    console.error("检测类名时出错:", error);
     return null;
   }
-};
 
-/**
- * 检测方法名
- * @param {string} method_name 方法名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkMethodName = function (method_name, node) {
-  try {
-    var rule = this.config.getRule("method-name");
-    if (!rule) {
-      return null;
+  /**
+   * 检测函数类型
+   * @param {object} node AST节点
+   * @returns {string} 类型名称
+   */
+  detectFunctionType(node) {
+    if (node.type === 'FunctionDeclaration') {
+      return 'function';
     }
 
-    // 检查是否为忽略词（在所有检测之前）
-    if (this._isIgnoredWord(method_name, "method-name")) {
-      return null;
+    // 检测函数表达式内部的函数名
+    if (node.type === 'FunctionExpression' && node.id && node.id.type === 'Identifier') {
+      return 'function';
     }
 
-    // 检查命名风格（支持公开方法和私有方法）
-    var style_err = null;
-    if (method_name.startsWith("_")) {
-      // 私有方法：检查是否符合私有方法命名规范
-      style_err = this._validate_naming_style(
-        method_name,
-        ["_camelCase"],
-        "method-name",
-      );
-    } else {
-      // 公开方法：检查是否符合公开方法命名规范
-      style_err = this._validate_naming_style(
-        method_name,
-        rule.styles,
-        "method-name",
-      );
-    }
-
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        method_name,
-        "method-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== method_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      method_name,
-      rule.min,
-      rule.max,
-      "method-name",
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        method_name,
-        "method-name",
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== method_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
+    if (node.type === 'VariableDeclaration' && node.declarations && node.declarations.length > 0) {
+      var decl = node.declarations[0];
+      if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
+        return 'function';
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      method_name,
-      rule.single_word_len,
-      "method-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          method_name,
-          "method-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== method_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
+    }
+
+    // 检测VariableDeclarator节点中的箭头函数
+    if (node.type === 'VariableDeclarator' && node.init &&
+      (node.init.type === 'FunctionExpression' || node.init.type === 'ArrowFunctionExpression')) {
+      return 'function';
+    }
+
+    if (node.type === 'Property' && node.value &&
+      (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
+      return 'property-function';
+    }
+
+    if (node.type === 'MethodDefinition') {
+      // 检测私有方法（ES6私有方法语法 # 前缀）
+      if (node.key && node.key.type === 'PrivateIdentifier') {
+        return 'private-function';
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(method_name, "method-name");
-    if (forbid_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        method_name,
-        "method-name",
-      );
-      var error_message = forbid_err;
-      if (smart_abbreviation && smart_abbreviation !== method_name) {
-        error_message = forbid_err + "，建议使用: " + smart_abbreviation;
+
+      // 检测传统私有方法约定（_ 前缀）
+      if (node.key && node.key.type === 'Identifier' && node.key.name.startsWith('_')) {
+        return node.static ? 'static-function' : 'internal-function';
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 如果没有错误但有推荐建议，返回优化建议
-    var smart_abbreviation = this._getSmartAbbreviation(
-      method_name,
-      "method-name",
-    );
-    if (smart_abbreviation && smart_abbreviation !== method_name) {
-      return {
-        node: node,
-        message:
-          "方法名'" +
-          method_name +
-          "'不是行业通用名，建议使用: " +
-          smart_abbreviation,
-        fix: function (fixer) {
-          return fixer.replaceText(node, smart_abbreviation);
-        },
-      };
+
+      return node.static ? 'static-function' : 'function';
+    }
+
+    if (node.type === 'PropertyDefinition' && node.value &&
+      (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
+      return node.static ? 'static-function' : 'property-function';
+    }
+
+    if (node.type === 'AssignmentExpression' && node.right &&
+      (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
+      return 'property-function';
+    }
+
+    if (node.type === 'CallExpression' && node.callee && node.callee.type === 'Identifier') {
+      // 函数调用应该被识别为函数使用，而不是函数定义
+      return 'use-function';
     }
 
-    return null;
-  } catch (error) {
-    console.error("检测方法名时出错:", error);
     return null;
   }
-};
 
-/**
- * 检测函数名
- * @param {string} function_name 函数名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkFunctionName = function (function_name, node) {
-  try {
-    var rule = this.config.getRule("function-name");
-    if (!rule) {
-      return null;
+  /**
+   * 检测变量类型
+   * @param {object} node AST节点
+   * @returns {string} 类型名称
+   */
+  detectVariableType(node) {
+    // let/var 声明
+    if (node.type === 'VariableDeclaration' && (node.kind === 'let' || node.kind === 'var')) {
+      return 'variable';
     }
 
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(function_name, "function-name")) {
-      return null;
+    // for 循环中的变量
+    if (node.type === 'ForStatement' && node.init && node.init.type === 'VariableDeclaration' &&
+      (node.init.kind === 'let' || node.init.kind === 'var')) {
+      return 'variable';
     }
 
-    // 检查是否为私有函数（不允许私有函数）
-    if (function_name.startsWith("_")) {
-      // 生成建议：去掉下划线前缀，转换为公有函数
-      var public_function_name = function_name.substring(1);
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        public_function_name,
-        "function-name",
-      );
-      var recommended_name =
-        smart_abbreviation && smart_abbreviation !== public_function_name
-          ? smart_abbreviation
-          : public_function_name;
-
-      return {
-        node: node,
-        message:
-          "函数名'" +
-          function_name +
-          "'不允许声明私有函数，建议使用: " +
-          recommended_name,
-      };
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      function_name,
-      rule.styles,
-      "function-name",
-    );
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        function_name,
-        "function-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== function_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
+    // 对象属性变量 - 先排除函数类型和常量属性
+    if ((node.type === 'Property' || node.type === 'ObjectProperty')) {
+      // 如果是函数类型，不应该识别为变量
+      if (node.value && (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
+        return null;
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      function_name,
-      rule.min,
-      rule.max,
-      "function-name",
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        function_name,
-        "function-name",
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== function_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
+      // 属性简写（如 { user_name }）应该识别为变量
+      if (node.shorthand && node.value && node.value.type === 'Identifier') {
+        return 'property-variable';
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      function_name,
-      rule.single_word_len,
-      "function-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          function_name,
-          "function-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== function_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
+      // 只有字面量值且不是常量属性才识别为变量
+      if (this._isLiteralValue(node.value)) {
+        // 检查是否为常量属性（父级是const声明）
+        var parent_type = this._getParentDeclarationType(node);
+        if (parent_type !== 'const') {
+          return 'property-variable';
         }
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(function_name, "function-name");
-    if (forbid_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        function_name,
-        "function-name",
-      );
-      var error_message = forbid_err;
-      if (smart_abbreviation && smart_abbreviation !== function_name) {
-        error_message = forbid_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
-    var recommend_info = this._checkAndRecommend(
-      function_name,
-      "function-name",
-    );
-    if (recommend_info) {
-      // 如果有推荐建议，提示可以使用更简洁的词汇
-      return {
-        node: node,
-        message:
-          "函数名'" +
-          function_name +
-          "'建议使用: " +
-          recommend_info.recommended_name,
-      };
     }
 
-    return null;
-  } catch (error) {
-    console.error("检测函数名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检测变量名
- * @param {string} variable_name 变量名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkVariableName = function (variable_name, node) {
-  try {
-    var rule = this.config.getRule("variable-name");
-    if (!rule) {
-      return null;
+    // 类属性变量
+    if (node.type === 'PropertyDefinition' && this._isLiteralValue(node.value)) {
+      return node.static ? 'static-variable' : 'property-variable';
     }
 
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(variable_name, "variable-name")) {
-      return null;
+    // 赋值表达式
+    if (node.type === 'AssignmentExpression' && this._isLiteralValue(node.right)) {
+      return 'property-variable';
     }
 
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      variable_name,
-      rule.styles,
-      "variable-name",
-    );
-    if (style_err) {
-      return {
-        node: node,
-        message: style_err,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      variable_name,
-      rule.min,
-      rule.max,
-      "variable-name",
-    );
-    if (len_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = len_err;
-      if (!len_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          variable_name,
-          "variable-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== variable_name) {
-          error_message = len_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
+    return null;
+  }
 
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      variable_name,
-      rule.single_word_len,
-      "variable-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          variable_name,
-          "variable-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== variable_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
+  /**
+   * 检测声明方式问题
+   * @param {object} node AST节点
+   * @returns {string} 问题类型
+   */
+  detectDeclarationIssue(node) {
+    // const 声明但包含非基础字面量 - 应该用let而不是const
+    if (node.type === 'VariableDeclaration' && node.kind === 'const') {
+      if (node.declarations && node.declarations.length > 0) {
+        var decl = node.declarations[0];
+        if (decl.init && !this._isBasicLiteralValue(decl.init)) {
+          // 排除函数表达式和箭头函数表达式，它们应该使用const声明
+          if (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression') {
+            return null;
+          }
+          return 'const-should-be-let';
         }
       }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(variable_name, "variable-name");
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-      };
     }
 
-    return null;
-  } catch (error) {
-    console.error("检测变量名时出错:", error);
     return null;
   }
-};
 
-/**
- * 检测参数名
- * @param {string} param_name 参数名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkParamName = function (param_name, node) {
-  try {
-    var rule = this.config.getRule("param-name");
-    if (!rule) {
-      return null;
+  /**
+   * 检测常量类型
+   * @param {object} node AST节点
+   * @returns {string} 类型名称
+   */
+  detectConstantType(node) {
+    // const 声明 - 当右侧是字面量值（包括对象和数组）时视为常量
+    if (node.type === 'VariableDeclaration' && node.kind === 'const') {
+      // 检查右侧是否是字面量值
+      if (node.declarations && node.declarations.length > 0) {
+        var decl = node.declarations[0];
+        if (decl.init && this._isLiteralValue(decl.init)) {
+          return 'constant';
+        }
+      }
     }
 
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(param_name, "param-name")) {
-      return null;
+    // var 和 let 声明应该被识别为变量，而不是常量
+    if (node.type === 'VariableDeclaration' && (node.kind === 'var' || node.kind === 'let')) {
+      return null; // 返回null，让其他检测器处理
     }
 
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      param_name,
-      rule.styles,
-      "param-name",
-    );
-    if (style_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        param_name,
-        "param-name",
-      );
-      var error_message = style_err;
-      if (smart_abbreviation && smart_abbreviation !== param_name) {
-        error_message = style_err + "，建议使用: " + smart_abbreviation;
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      param_name,
-      rule.min,
-      rule.max,
-      "param-name",
-    );
-    if (len_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = len_err;
-      if (!len_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          param_name,
-          "param-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== param_name) {
-          error_message = len_err + "，建议使用: " + smart_abbreviation;
+    // 对象属性常量 - 只有当父级是const声明且属性值是字面量时才视为常量
+    if ((node.type === 'Property' || node.type === 'ObjectProperty')) {
+      // 只有当值是字面量时才视为常量
+      if (this._isLiteralValue(node.value)) {
+        var parent_type = this._getParentDeclarationType(node);
+        if (parent_type === 'const') {
+          return 'property-constant';
         }
       }
+    }
 
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      param_name,
-      rule.single_word_len,
-      "param-name",
-    );
-    if (word_err) {
-      // 检查错误消息是否已经包含建议
-      var error_message = word_err;
-      if (!word_err.includes("建议使用")) {
-        // 如果错误消息中不包含建议，则添加建议
-        var smart_abbreviation = this._getSmartAbbreviation(
-          param_name,
-          "param-name",
-        );
-        if (smart_abbreviation && smart_abbreviation !== param_name) {
-          error_message = word_err + "，建议使用: " + smart_abbreviation;
-        }
-      }
-      return {
-        node: node,
-        message: error_message,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(param_name, "param-name");
-    if (forbid_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        param_name,
-        "param-name",
-      );
-      var error_message = forbid_err;
-      if (smart_abbreviation && smart_abbreviation !== param_name) {
-        error_message = forbid_err + "，建议使用: " + smart_abbreviation;
+    // 类属性常量 - 只有当属性名符合常量命名规范时才识别为常量
+    if (node.type === 'PropertyDefinition' && this._isLiteralValue(node.value)) {
+      if (node.static) {
+        return 'static-variable';
       }
-      return {
-        node: node,
-        message: error_message,
-      };
+      // 类中的静态属性应该被识别为静态属性-变量，而不是静态属性-常量
+      return 'variable';
     }
 
-    return null;
-  } catch (error) {
-    console.error("检测参数名时出错:", error);
     return null;
   }
-};
-
-/**
- * 检测常量名
- * @param {string} constant_name 常量名
- * @param {object} node AST节点
- * @param {object} val_node 值节点（用于识别基础值）
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkConstantName = function (
-  constant_name,
-  node,
-  val_node,
-) {
-  try {
-    // 检查是否为解构导入（从模块导入的变量）
-    var is_destructured_import = this._isDestructuredImport(node);
-
-    // 如果是解构导入，则不进行命名检测
-    if (is_destructured_import) {
-      return null;
-    }
 
-    // 检查是否应该使用let而不是const
-    var should_use_let = this._shouldUseLetInsteadOfConst(node, val_node);
+  /**
+   * 检测参数类型
+   * @param {object} node AST节点
+   * @returns {string} 类型名称
+   */
+  detectParamType(node) {
+    // 只在真正的函数参数节点上返回参数类型
+    if (node.type === 'Identifier' && node.parent &&
+      (node.parent.type === 'FunctionDeclaration' ||
+        node.parent.type === 'FunctionExpression' ||
+        node.parent.type === 'ArrowFunctionExpression') &&
+      node.parent.params && node.parent.params.includes(node)) {
+
+      // 增强版参数类型检测：根据使用上下文推断参数类型
+      var param_type = this._inferParamTypeFromContext(node);
+
+      // 如果使用上下文无法推断，尝试其他方法
+      if (!param_type) {
+        // 基于命名约定推断（优先级高于命名风格）
+        param_type = this._inferParamTypeByNamingConvention(node.name);
+
+        // 如果命名约定也无法推断，基于命名风格推断
+        if (!param_type) {
+          param_type = this._inferParamTypeByStyle(node.name);
+        }
+      }
 
-    // 如果应该使用let，则提示开发者
-    if (should_use_let) {
-      return {
-        node: node,
-        message: `变量'${constant_name}'应该使用let而不是const声明，因为它不是真正的常量`,
-      };
+      // 对于箭头函数参数，优先推断为变量类型
+      if (node.parent && node.parent.type === 'ArrowFunctionExpression') {
+        param_type = 'variable';
+      }
+      return param_type ? 'param-' + param_type : 'param';
     }
 
-    // 根据值类型确定应该应用的命名规则
-    var rule_type = "constant-name"; // 默认使用常量命名规则
-    var allowed_styles = [];
+    // 不是参数节点，返回null让其他检测器处理
+    return null;
+  }
 
-    // 检查是否为函数表达式或箭头函数
-    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;
+  /**
+   * 根据上下文推断参数类型
+   * @param {object} param_node 参数节点
+   * @returns {string} 参数类型（function/class/variable）
+   */
+  _inferParamTypeFromContext(param_node) {
+    var function_node = param_node.parent;
+    var param_name = param_node.name;
+
+    // 如果没有函数体，无法进行使用上下文推断
+    if (!function_node.body) {
+      return null; // 无法推断，返回null让上层逻辑处理
     }
 
-    // 获取对应的命名规则
-    // 将属性规则类型映射到对应的基础规则类型（用于获取规则配置）
-    var 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';
+    // 收集参数在函数体中的所有使用方式
+    var usage_types = [];
+
+    this._traverseFunctionBody(function_node.body, function (node) {
+      // 检查调用表达式：param_name() → 函数类型
+      if (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === param_name) {
+        usage_types.push('function_call');
       }
-      // 属性值名 -> 变量名
-      else if (rule_type === 'property-value-name') {
-        rule_config_type = 'variable-name';
+
+      // 检查new表达式：new param_name() → 类类型
+      else if (node.type === 'NewExpression' &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === param_name) {
+        usage_types.push('class_instantiation');
       }
-    }
-    
-    var rule = this.config.getRule(rule_config_type);
-    if (!rule) {
-      return null;
-    }
 
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, rule_type)) {
-      return null;
-    }
+      // 检查成员表达式：param_name.property → 对象类型
+      else if (node.type === 'MemberExpression' &&
+        node.object.type === 'Identifier' &&
+        node.object.name === param_name) {
+        usage_types.push('property_access');
+      }
 
-    // 检查命名风格
-    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;
+      // 检查方法调用：param_name.method() → 对象类型（类实例）
+      else if (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === param_name) {
+        usage_types.push('method_call');
       }
 
-      return {
-        node: node,
-        message: error_message,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      constant_name,
-      rule.min,
-      rule.max,
-      rule_type,
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(
-        constant_name,
-        rule_type,
-      );
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== constant_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
+      // 检查赋值表达式：var x = param_name → 变量类型
+      else if (node.type === 'VariableDeclarator' &&
+        node.init && node.init.type === 'Identifier' &&
+        node.init.name === param_name) {
+        usage_types.push('variable_assignment');
       }
 
-      return {
-        node: node,
-        message: error_message,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      constant_name,
-      rule.single_word_len,
-      rule_type,
-    );
-    if (word_err) {
-      return {
-        node: node,
-        message: word_err,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(constant_name, rule_type);
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
-
-    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
-    var recommend_info = this._checkAndRecommend(constant_name, rule_type);
-    if (recommend_info) {
-      // 根据规则类型生成正确的错误消息
-      var name_type_text = "";
-      switch (rule_type) {
-        case "function-name":
-          name_type_text = "函数名";
-          break;
-        case "class-name":
-          name_type_text = "类名";
-          break;
-        case "constant-name":
-          name_type_text = "常量名";
-          break;
-        case "variable-name":
-          name_type_text = "变量名";
-          break;
-        default:
-          name_type_text = "名称";
+      // 检查作为参数传递：func(param_name) → 根据接收函数的上下文推断
+      else if (node.type === 'CallExpression') {
+        for (var i = 0; i < node.arguments.length; i++) {
+          var arg = node.arguments[i];
+          if (arg.type === 'Identifier' && arg.name === param_name) {
+            usage_types.push('function_argument');
+          }
+        }
       }
 
-      return {
-        node: node,
-        message:
-          name_type_text +
-          "'" +
-          constant_name +
-          "'长度过长，最大长度为20字符，建议使用: " +
-          recommend_info.recommended_name,
-        rule_type: rule_type, // 返回正确的规则类型
-      };
-    }
+      // 检查直接使用：return name, var x = name → 变量类型
+      else if (node.type === 'Identifier' && node.name === param_name) {
+        // 排除已经在其他检测中处理的情况
+        var parent = node.parent;
+        if (!parent ||
+          (parent.type !== 'CallExpression' &&
+            parent.type !== 'NewExpression' &&
+            parent.type !== 'MemberExpression' &&
+            !(parent.type === 'VariableDeclarator' && parent.init === node))) {
+          usage_types.push('direct_usage');
+        }
+      }
 
-    return null;
-  } catch (error) {
-    console.error("检测常量名时出错:", error);
-    return null;
-  }
-};
+      return false; // 继续遍历，收集所有使用方式
+    });
 
-/**
- * 验证命名风格
- * @param {string} name 名称
- * @param {Array} styles 允许的风格列表
- * @param {string} name_type 名称类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._validate_naming_style = function (name, styles, name_type) {
-  if (!name || !styles || !Array.isArray(styles)) {
-    return null;
+    // 根据使用方式推断参数类型
+    return this._inferTypeFromUsage(usage_types, param_name);
   }
 
-  for (var i = 0; i < styles.length; i++) {
-    var style = styles[i];
-    var regex = this.config.getRegex(style);
-    if (regex && regex.test(name)) {
+  /**
+   * 根据使用方式推断参数类型
+   * @param {Array} usage_types 使用方式数组
+   * @param {string} param_name 参数名
+   * @returns {string} 推断的参数类型
+   */
+  _inferTypeFromUsage(usage_types, param_name) {
+    // 如果没有使用方式，无法推断
+    if (usage_types.length === 0) {
       return null;
     }
-  }
 
-  var style_names = styles.join("或");
+    // 优先级：函数调用 > 类实例化 > 方法调用 > 属性访问 > 函数参数 > 变量赋值 > 直接使用
+    var priority_map = {
+      'function_call': 7,      // 最高优先级：明确是函数
+      'class_instantiation': 6, // 高优先级：明确是类
+      'method_call': 5,        // 中高优先级：方法调用（类实例）
+      'property_access': 4,     // 中优先级：对象属性访问
+      'function_argument': 3,   // 低优先级：作为函数参数传递（根据接收函数推断）
+      'variable_assignment': 2, // 较低优先级：变量赋值
+      'direct_usage': 1         // 最低优先级：直接使用
+    };
 
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
+    // 找到最高优先级的用法
+    var highest_priority = 0;
+    var inferred_type = null;
 
-  return name_type_desc + "'" + name + "'不符合" + style_names + "命名风格";
-};
+    for (var i = 0; i < usage_types.length; i++) {
+      var usage = usage_types[i];
+      var priority = priority_map[usage] || 0;
 
-/**
- * 检查名称长度
- * @param {string} name 名称
- * @param {number} min 最小长度
- * @param {number} max 最大长度
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkNameLength = function (name, min, max, name_type) {
-  if (!name) {
-    return "名称不能为空";
-  }
+      if (priority > highest_priority) {
+        highest_priority = priority;
 
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-  var len = name.length;
-  if (len < min) {
-    return name_type_desc + "'" + name + "'长度过短，最小长度为" + min + "字符";
-  }
+        // 根据使用方式映射到参数类型
+        switch (usage) {
+          case 'function_call':
+            inferred_type = 'function';
+            break;
+          case 'class_instantiation':
+            inferred_type = 'class';
+            break;
+          case 'method_call':
+            inferred_type = 'class-instance';
+            break;
+          case 'property_access':
+            inferred_type = 'object';
+            break;
+          case 'function_argument':
+            // 作为函数参数传递，需要根据接收函数的上下文推断
+            inferred_type = 'variable';  // 默认变量类型，让其他使用方式覆盖
+            break;
+          case 'variable_assignment':
+          case 'direct_usage':
+            inferred_type = 'variable';
+            break;
+        }
+      }
+    }
 
-  if (len > max) {
-    return name_type_desc + "'" + name + "'长度过长，最大长度为" + max + "字符";
+    return inferred_type;
   }
 
-  return null;
-};
+  /**
+   * 基于命名约定推断参数类型
+   * @param {string} param_name 参数名
+   * @returns {string} 推断的参数类型
+   */
+  _inferParamTypeByNamingConvention(param_name) {
+    var lower_name = param_name.toLowerCase();
+
+    // 函数类型命名约定
+    if (lower_name.startsWith('on') ||
+      lower_name.startsWith('handle') ||
+      lower_name.endsWith('func') ||
+      lower_name.endsWith('callback') ||
+      lower_name.endsWith('handler')) {
+      return 'function';
+    }
+
+    // 类类型命名约定
+    if (lower_name.endsWith('manager') ||
+      lower_name.endsWith('service') ||
+      lower_name.endsWith('controller') ||
+      lower_name.endsWith('provider') ||
+      lower_name.endsWith('factory') ||
+      lower_name.endsWith('class') ||
+      lower_name.endsWith('model') ||
+      lower_name.endsWith('view') ||
+      lower_name.endsWith('component')) {
+      return 'class';
+    }
+
+    // 对象类型命名约定
+    if (lower_name.endsWith('obj') ||
+      lower_name.endsWith('object') ||
+      lower_name.endsWith('data') ||
+      lower_name.endsWith('info') ||
+      lower_name.endsWith('config') ||
+      lower_name.endsWith('options')) {
+      return 'variable';
+    }
 
-/**
- * 检查单词长度
- * @param {string} name 名称
- * @param {number} max_word_len 最大单词长度
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
-  if (!name || !max_word_len) {
     return null;
   }
 
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-
-  // 处理私有标识符（开头的下划线）
-  var processed_name = name;
-  var has_private_prefix = false;
+  /**
+   * 基于命名风格推断参数类型
+   * @param {string} param_name 参数名
+   * @returns {string} 推断的参数类型
+   */
+  _inferParamTypeByStyle(param_name) {
+    var config = this.config || new (require('./config').Config)();
 
-  if (name.startsWith("_")) {
-    has_private_prefix = true;
-    processed_name = name.substring(1); // 去掉开头的下划线
-  }
+    // 检查是否符合PascalCase（类类型）
+    if (config.getRegex('PascalCase').test(param_name)) {
+      return 'class';
+    }
 
-  // 分割单词（根据命名风格）
-  var words = [];
+    // 检查是否符合snake_case（变量/对象类型）
+    if (config.getRegex('snake_case').test(param_name)) {
+      return 'variable';
+    }
 
-  if (processed_name.includes("_")) {
-    words = processed_name.split("_");
-  } else if (processed_name.includes("-")) {
-    words = processed_name.split("-");
-  } else {
-    // 驼峰命名法分割（保持原词大小写）
-    words = processed_name.split(/(?=[A-Z])/);
-  }
+    // 检查是否符合camelCase（函数类型）
+    if (config.getRegex('camelCase').test(param_name)) {
+      return 'function';
+    }
 
-  // 如果存在私有标识符，添加空字符串表示私有标识符（不检查长度）
-  if (has_private_prefix) {
-    words.unshift("_");
+    // 默认变量类型
+    return 'variable';
   }
 
-  // 过滤空字符串
-  words = words.filter(function (word) {
-    return word && word.length > 0;
-  });
+  /**
+   * 语义推断参数类型
+   * @param {object} param_node 参数节点
+   * @returns {string} 推断的参数类型
+   */
+  _inferParamTypeSemantically(param_node) {
+    var function_node = param_node.parent;
+    var param_name = param_node.name;
+
+    // 收集函数体中所有标识符
+    var identifiers = [];
+    this._traverseFunctionBody(function_node.body, function (node) {
+      if (node.type === 'Identifier') {
+        identifiers.push({
+          name: node.name,
+          type: this._getIdentifierUsageType(node),
+          node: node
+        });
+      }
+      return false;
+    }.bind(this));
+
+    // 分析标识符与参数的语义关联
+    for (var i = 0; i < identifiers.length; i++) {
+      var identifier = identifiers[i];
+
+      // 检查标识符是否与参数名称有语义关联
+      if (this._hasSemanticRelation(param_name, identifier.name)) {
+        // 根据标识符的使用类型推断参数类型
+        switch (identifier.type) {
+          case 'function_call':
+            return 'function';
+          case 'class_instantiation':
+            return 'class';
+          case 'property_access':
+            return 'class-instance';
+          case 'variable_declaration':
+            return 'variable';
+        }
+      }
+    }
 
-  // 如果是单个单词，则不检测单词长度
-  if (words.length <= 1) {
     return null;
   }
 
-  for (var i = 0; i < words.length; i++) {
-    var word = words[i];
-    // 跳过空字符串和私有标识符（单个下划线）
-    if (!word || word === "_") {
-      continue;
-    }
+  /**
+   * 检查两个标识符是否有语义关联
+   * @param {string} param_name 参数名
+   * @param {string} identifier_name 标识符名
+   * @returns {boolean} 是否有语义关联
+   */
+  _hasSemanticRelation(param_name, identifier_name) {
+    // 简单的语义关联规则
 
-    if (word.length > max_word_len) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(name, name_type);
-      var recommendation_text = "";
-      if (smart_abbreviation && smart_abbreviation !== name) {
-        recommendation_text = "，建议使用: " + smart_abbreviation;
-      }
+    // 1. 名称相似性检查（忽略大小写和下划线）
+    var normalized_param = param_name.toLowerCase().replace(/[_-]/g, '');
+    var normalized_ident = identifier_name.toLowerCase().replace(/[_-]/g, '');
 
-      return (
-        name_type_desc +
-        "'" +
-        name +
-        "'中的单词'" +
-        word +
-        "'过长，最大长度为" +
-        max_word_len +
-        "字符" +
-        recommendation_text
-      );
+    if (normalized_param === normalized_ident) {
+      return true;
     }
-  }
 
-  return null;
-};
+    // 2. 包含关系检查
+    if (normalized_ident.includes(normalized_param) ||
+      normalized_param.includes(normalized_ident)) {
+      return true;
+    }
 
-/**
- * 检查禁止词汇
- * @param {string} name 名称
- * @param {string} name_type 名称类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkForbiddenWords = function (name, name_type) {
-  if (!name || !name_type) {
-    return null;
-  }
+    // 3. 词根相似性检查
+    var param_root = this._getWordRoot(normalized_param);
+    var ident_root = this._getWordRoot(normalized_ident);
 
-  var forbidden_words = this.config.getForbiddenWords(name_type);
-  if (!forbidden_words || !Array.isArray(forbidden_words)) {
-    return null;
+    if (param_root && ident_root && param_root === ident_root) {
+      return true;
+    }
+
+    return false;
   }
 
-  var name_type_desc = this.config.name_type_map[name_type] || "名称";
-  var name_lower = name.toLowerCase();
+  /**
+   * 获取标识符的使用类型
+   * @param {object} identifier_node 标识符节点
+   * @returns {string} 使用类型
+   */
+  _getIdentifierUsageType(identifier_node) {
+    var parent = identifier_node.parent;
 
-  // 对于私有变量/方法（以_开头），如果是单个单词（移除_后没有其他分隔符），则跳过禁止词汇检查
-  if (name_lower.startsWith("_") && name.length > 2) {
-    // 移除前缀_后检查是否包含分隔符
-    var name_without_prefix = name.substring(1);
-    if (!name_without_prefix.includes("_") && !name_without_prefix.includes("-") && !/[A-Z]/.test(name_without_prefix)) {
-      return null; // 单个单词的私有变量，跳过检查
+    if (parent.type === 'CallExpression' && parent.callee === identifier_node) {
+      return 'function_call';
     }
-  }
 
-  // 如果名称本身就是禁止词汇（即单个单词），则允许使用
-  for (var i = 0; i < forbidden_words.length; i++) {
-    var forbidden_word = forbidden_words[i].toLowerCase();
-    if (name_lower === forbidden_word) {
-      return null; // 单个单词允许使用
+    if (parent.type === 'NewExpression' && parent.callee === identifier_node) {
+      return 'class_instantiation';
     }
-  }
 
-  // 按单词边界分割名称（使用原始名称进行拆分，保持大小写信息）
-  var words = this._splitNameIntoWords(name);
-  
-  // 将拆分后的单词转换为小写进行比较
-  var words_lower = words.map(function(word) {
-    return word.toLowerCase();
-  });
-
-  // 检查每个单词是否在禁止词汇列表中
-  var found_forbidden_words = [];
-  
-  // 对于私有变量（以_开头），跳过第一个单词（即_）
-  var start_index = name_lower.startsWith("_") ? 1 : 0;
-  
-  for (var i = start_index; i < words_lower.length; i++) {
-    var word = words_lower[i];
-    // 跳过空字符串和单个字符
-    if (!word || word.length <= 1) {
-      continue;
-    }
-
-    for (var j = 0; j < forbidden_words.length; j++) {
-      var forbidden_word = forbidden_words[j].toLowerCase();
-      if (word === forbidden_word) {
-        // 记录找到的禁用词，但不立即返回
-        if (found_forbidden_words.indexOf(forbidden_word) === -1) {
-          found_forbidden_words.push(forbidden_word);
-        }
-      }
+    if (parent.type === 'MemberExpression' && parent.object === identifier_node) {
+      return 'property_access';
     }
-  }
 
-  // 如果有找到禁用词，返回错误信息
-  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(", ");
+    if (parent.type === 'VariableDeclarator' && parent.id === identifier_node) {
+      return 'variable_declaration';
     }
-    
-    return error_message;
-  }
-
-  return null;
-};
 
-/**
- * 按单词边界分割名称
- * @param {string} name 名称
- * @returns {Array} 单词数组
- */
-Detector.prototype._splitNameIntoWords = function (name) {
-  if (!name) {
-    return [];
+    return 'other';
   }
 
-  var words = [];
-  var processed_name = name;
-  var has_private_prefix = false;
+  /**
+   * 获取单词的词根（简化实现）
+   * @param {string} word 单词
+   * @returns {string} 词根
+   */
+  _getWordRoot(word) {
+    // 简单的词根提取规则
+    var common_suffixes = ['s', 'es', 'ed', 'ing', 'er', 'or', 'ment', 'tion', 'ity'];
 
-  // 处理私有标识符（开头的下划线）
-  if (name.startsWith("_")) {
-    has_private_prefix = true;
-    processed_name = name.substring(1); // 去掉开头的下划线
-  }
+    for (var i = 0; i < common_suffixes.length; i++) {
+      var suffix = common_suffixes[i];
+      if (word.endsWith(suffix) && word.length > suffix.length) {
+        return word.slice(0, -suffix.length);
+      }
+    }
 
-  // 如果移除_后为空，说明只有_，直接返回
-  if (!processed_name) {
-    return ["_"];
+    return word;
   }
 
-  // 根据命名风格分割单词
-  if (processed_name.includes("_")) {
-    words = processed_name.split("_");
-  } else if (processed_name.includes("-")) {
-    words = processed_name.split("-");
-  } else {
-    // 驼峰命名法分割（保持原词大小写）
-    words = processed_name.split(/(?=[A-Z])/);
-  }
+  /**
+   * 遍历函数体
+   * @param {object} body_node 函数体节点
+   * @param {function} visitor 访问器函数
+   */
+  _traverseFunctionBody(body_node, visitor) {
+    if (!body_node || !visitor) return;
 
-  // 如果存在私有标识符，添加下划线作为第一个单词
-  if (has_private_prefix) {
-    words.unshift("_");
-  }
+    // 简单的AST遍历实现
+    var nodes_to_visit = [body_node];
 
-  // 过滤空字符串
-  words = words.filter(function (word) {
-    return word && word.length > 0;
-  });
+    while (nodes_to_visit.length > 0) {
+      var current_node = nodes_to_visit.pop();
 
-  return words;
-};
+      // 调用访问器，如果返回true则停止遍历
+      if (visitor(current_node)) {
+        return;
+      }
 
-/**
- * 检查是否为第三方库的配置参数
- * @param {object} node AST节点
- * @param {object} parent_node 父节点
- * @returns {boolean} 是否为第三方库配置参数
- */
-Detector.prototype._isThirdPartyConfigProperty = function (node, parent_node) {
-  try {
-    // 处理新的父节点信息结构（包含node和parent属性）
-    var actual_parent_node = parent_node;
-    if (parent_node && typeof parent_node === "object" && parent_node.node) {
-      actual_parent_node = parent_node.node;
-    }
+      // 添加子节点到遍历队列
+      if (current_node.body) {
+        if (Array.isArray(current_node.body)) {
+          nodes_to_visit.push(...current_node.body.reverse());
+        } else {
+          nodes_to_visit.push(current_node.body);
+        }
+      }
 
-    // 检查当前节点是否为对象字面量的属性
-    if (!actual_parent_node || actual_parent_node.type !== "ObjectExpression") {
-      return false;
-    }
+      if (current_node.expression) {
+        nodes_to_visit.push(current_node.expression);
+      }
 
-    // 递归查找调用表达式（处理嵌套对象的情况）
-    var findCallExpression = function (current_node) {
-      if (!current_node) {
-        return null;
+      if (current_node.consequent) {
+        nodes_to_visit.push(current_node.consequent);
       }
 
-      if (current_node.type === "CallExpression") {
-        return current_node;
+      if (current_node.alternate) {
+        nodes_to_visit.push(current_node.alternate);
       }
 
-      // 继续向上查找
-      return findCallExpression(current_node.parent);
-    };
+      if (current_node.argument) {
+        nodes_to_visit.push(current_node.argument);
+      }
 
-    // 优先使用新的父节点信息结构中的parent属性
-    var grandparent =
-      parent_node && typeof parent_node === "object" && parent_node.parent
-        ? parent_node.parent
-        : actual_parent_node.parent;
+      if (current_node.arguments && Array.isArray(current_node.arguments)) {
+        nodes_to_visit.push(...current_node.arguments.reverse());
+      }
 
-    // 查找调用表达式
-    var call_expression = findCallExpression(grandparent);
-    if (!call_expression) {
-      return false;
-    }
+      if (current_node.elements && Array.isArray(current_node.elements)) {
+        nodes_to_visit.push(...current_node.elements.reverse());
+      }
 
-    // 检查方法调用是否来自外部模块（非当前文件定义的函数）
-    var callee = call_expression.callee;
-    if (!callee) {
-      return false;
+      if (current_node.properties && Array.isArray(current_node.properties)) {
+        nodes_to_visit.push(...current_node.properties.reverse());
+      }
     }
+  }
 
-    // 如果是成员表达式（如 chokidar.watch），则认为是第三方库调用
-    if (callee.type === "MemberExpression") {
-      // 检查成员表达式的对象是否为模块导入变量
-      var is_module_import = this._isModuleImportVariable(callee.object);
-      if (is_module_import) {
-        return true;
-      }
+  /**
+   * 检测命名类型
+   * @param {object} node AST节点
+   * @param {string} name 名称
+   * @returns {object} 检测结果
+   */
+  detect(node, name) {
+    var type = null;
+
+    // 按优先级检测类型 - 变量检测应该在常量检测之前
+    var detectors = [
+      this.detectClassType.bind(this),
+      this.detectClassInstanceType.bind(this),
+      this.detectFunctionType.bind(this),  // 函数检测应该在变量检测之前
+      this.detectConstantType.bind(this),   // 常量检测优先级提高
+      this.detectVariableType.bind(this),   // 变量检测优先级降低
+      this.detectParamType.bind(this)
+    ];
 
-      // 对于其他成员表达式，也认为是第三方库调用（保守策略）
-      return true;
+    for (var i = 0; i < detectors.length; i++) {
+      type = detectors[i](node);
+      if (type) {
+        break;
+      }
     }
 
-    // 如果是标识符，检查是否是常见的第三方库函数名
-    if (callee.type === "Identifier") {
-      var common_third_party_functions = [
-        "watch",
-        "require",
-        "import",
-        "create",
-        "build",
-        "compile",
-        "parse",
-        "stringify",
-        "readFile",
-        "writeFile",
-        "mkdir",
-        "exec",
-        "spawn",
-        "fork",
-        "connect",
-        "listen",
-        "send",
-      ];
-
-      // 如果是常见的第三方库函数名，则认为是第三方库调用
-      if (common_third_party_functions.includes(callee.name)) {
-        return true;
+    // 如果检测到类实例、函数等特殊类型，跳过声明问题检测
+    if (type && (type.includes('class-instance') || type.includes('function'))) {
+      // 跳过声明问题检测，直接进行命名规范验证
+    } else {
+      // 检测声明方式问题（优先级较低）
+      var original_type = this.detectDeclarationIssue(node);
+      if (original_type) {
+        // 如果是声明方式问题，直接返回相应的错误，不进行命名规范验证
+        var message = this.tip.getDeclarationIssueMessage(original_type, name);
+        return {
+          name,
+          node,
+          message,
+          error_type: 'declaration',
+          severity: 'error',
+          fix_suggestion: null,
+          original_type
+        };
       }
+    }
 
-      // 检查标识符是否为模块导入变量
-      var is_module_import = this._isModuleImportVariable(callee);
-      if (is_module_import) {
-        return true;
-      }
+    if (!type) {
+      type = 'variable'; // 默认类型
+    }
 
-      // 对于其他标识符，暂时不认为是第三方库调用（避免误判）
-      return false;
+    var error = this.validator.validate(name, type);
+    if (!error) {
+      return null;
     }
 
-    return false;
-  } catch (error) {
-    console.error("检查第三方库配置参数时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 获取属性类型
- * @param {object} val_node 属性值节点
- * @param {string} prop_name 属性名
- * @param {object} parent_node 父节点
- * @returns {string} 属性类型
- */
-Detector.prototype._getPropType = function (val_node, prop_name, parent_node) {
-  if (!val_node) {
-    return "undefined_value"; // 未赋值类型
-  }
-
-  // 检查是否为null值
-  if (val_node.type === "NullLiteral") {
-    return "null_value"; // null值类型
-  }
+    var fix_suggestion = this.corrector.getSuggestion(error);
+    var message = this.tip.getFullMessage(error, fix_suggestion);
 
-  // 检查是否为对象方法（在对象字面量中的函数）
-  if (
-    val_node &&
-    (val_node.type === "FunctionExpression" ||
-      val_node.type === "ArrowFunctionExpression")
-  ) {
-    return "method"; // 对象方法类型
+    return {
+      name,
+      node,
+      message,
+      error_type: error.type,
+      severity: error.severity,
+      fix_suggestion: fix_suggestion,
+      original_type: type
+    };
   }
 
-  // 检查是否为类引用（属性类）
-  if (
-    val_node.type === "Identifier" &&
-    val_node.name &&
-    val_node.name[0] === val_node.name[0].toUpperCase()
-  ) {
-    // 检查是否是特殊全局变量（如__dirname、__filename、process等）
-    var special_globals = [
-      "__dirname",
-      "__filename",
-      "process",
-      "console",
-      "module",
-      "exports",
-      "require",
-      "global",
+  /**
+   * 检测命名类型（仅返回类型，不验证）
+   * @param {object} node AST节点
+   * @returns {string} 检测到的类型
+   */
+  detectTypeOnly(node) {
+    var type = null;
+
+    // 按优先级检测类型 - 变量检测应该在常量检测之前
+    var detectors = [
+      this.detectClassType.bind(this),
+      this.detectClassInstanceType.bind(this),
+      this.detectFunctionType.bind(this),  // 函数检测应该在变量检测之前
+      this.detectConstantType.bind(this),   // 常量检测优先级提高
+      this.detectVariableType.bind(this),   // 变量检测优先级降低
+      this.detectParamType.bind(this)
     ];
-    if (special_globals.includes(val_node.name)) {
-      return "value"; // 特殊全局变量应该识别为属性值
-    }
-
-    // 检查是否是类名引用（通常类名使用PascalCase）
-    return "class"; // 属性类类型
-  }
 
-  // 检查是否为类实例（new表达式）
-  if (val_node.type === "NewExpression") {
-    return "instance_class"; // 属性实例类类型
-  }
-
-  // 检查是否为函数调用（可能返回实例）
-  if (val_node.type === "CallExpression") {
-    // 检查是否调用的是构造函数
-    if (
-      val_node.callee &&
-      val_node.callee.type === "Identifier" &&
-      val_node.callee.name &&
-      val_node.callee.name[0] === val_node.callee.name[0].toUpperCase()
-    ) {
-      return "instance_class"; // 属性实例类类型
-    }
-
-    // 检查是否是工厂方法（返回实例）
-    var factory_methods = ["create", "make", "build", "get", "fetch"];
-    if (
-      val_node.callee &&
-      val_node.callee.type === "Identifier" &&
-      factory_methods.some(function (method) {
-        return val_node.callee.name.toLowerCase().startsWith(method);
-      })
-    ) {
-      return "instance_class"; // 工厂方法返回的实例
-    }
-
-    return "value"; // 默认值类型
-  }
-
-  // 检查是否为数组（包含对象实例）
-  if (val_node.type === "ArrayExpression") {
-    // 检查数组元素是否包含类实例
-    if (val_node.elements && val_node.elements.length > 0) {
-      var has_instance = val_node.elements.some(function (element) {
-        return element && element.type === "NewExpression";
-      });
-      if (has_instance) {
-        return "instance_class"; // 包含实例的数组
+    for (var i = 0; i < detectors.length; i++) {
+      type = detectors[i](node);
+      if (type) {
+        break;
       }
     }
-    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"; // 包含实例的对象
-      }
+    // 特殊处理：属性简写应该识别为变量，而不是常量
+    if (node.type === 'Property' && node.shorthand && node.value && node.value.type === 'Identifier') {
+      // 如果是属性简写，强制识别为变量
+      type = 'property-variable';
     }
-    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"; // 包含实例的模板
-      }
+    if (!type) {
+      type = 'variable'; // 默认类型
     }
-    return "value"; // 普通模板
-  }
 
-  return "value";
-};
-
-/**
- * 检测属性名
- * @param {string} prop_name 属性名
- * @param {object} node AST节点
- * @param {object} val_node 属性值节点
- * @param {object} parent_node 父节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkPropertyName = function (
-  prop_name,
-  node,
-  val_node,
-  parent_node,
-) {
-  try {
-    // 检查是否为解构导入中的属性
-    var is_destructured_import = this._isDestructuredImportProperty(
-      node,
-      parent_node,
-    );
+    return type;
+  }
 
-    // 如果是解构导入中的属性，则不进行属性名检测
-    if (is_destructured_import) {
-      return null;
+  /**
+   * 判断是否为字面量值
+   * @param {object} node AST节点
+   * @returns {boolean} 是否为字面量
+   */
+  _isLiteralValue(node) {
+    if (!node) {
+      return false;
     }
 
-    // 检查是否为第三方库的配置参数（方法调用中的对象字面量属性）
-    var is_third_party_config = this._isThirdPartyConfigProperty(
-      node,
-      parent_node,
-    );
-
-    // 如果是第三方库的配置参数，则不进行属性名检测
-    if (is_third_party_config) {
-      return null;
+    switch (node.type) {
+      case 'Literal':
+        return !node.regex; // 排除正则表达式
+      case 'TemplateLiteral':
+        return true;
+      case 'Identifier':
+        var literal_identifiers = ['undefined', 'null', 'Infinity', 'NaN', 'true', 'false'];
+        return literal_identifiers.includes(node.name);
+      case 'ArrayExpression':
+        if (node.elements && node.elements.length > 0) {
+          for (var i = 0; i < node.elements.length; i++) {
+            if (!this._isLiteralValue(node.elements[i])) {
+              return false;
+            }
+          }
+        }
+        return true;
+      case 'ObjectExpression':
+        if (node.properties && node.properties.length > 0) {
+          for (var i = 0; i < node.properties.length; i++) {
+            var property = node.properties[i];
+            if (property.value && !this._isLiteralValue(property.value)) {
+              return false;
+            }
+          }
+        }
+        return true;
+      default:
+        return false;
     }
+  }
 
-    // 检查是否为 module.exports 中的属性
-    var is_module_exports = this._isModuleExportsProperty(node, parent_node);
-
-    // 如果是 module.exports 中的属性，则不进行属性名检测
-    if (is_module_exports) {
-      return null;
+  /**
+   * 判断字符串是否符合PascalCase命名规范
+   * @param {string} name 名称
+   * @returns {boolean} 是否符合PascalCase
+   */
+  _isPascalCase(name) {
+    if (!name || name.length === 0) {
+      return false;
     }
-
-    // 获取属性类型
-    var prop_type = this._getPropType(val_node, prop_name, parent_node);
-    var rule_type = "";
-
-    // 根据属性类型选择对应的规则
-    // 对于null值和未赋值属性，直接跳过命名规范检测
-    if (prop_type === "null_value" || prop_type === "undefined_value") {
-      return null; // 不进行命名规范检测
+    
+    // PascalCase要求首字母大写，后续字母可以大小写混合
+    // 但不能包含下划线或连字符
+    if (name.includes('_') || name.includes('-')) {
+      return false;
     }
-
-    switch (prop_type) {
-      case "class":
-        rule_type = "property-class-name";
-        break;
-      case "instance_class":
-        rule_type = "property-instance-class-name";
-        break;
-      case "method":
-        rule_type = "property-method-name";
-        break;
-      case "value":
-      default:
-        rule_type = "property-value-name";
-        break;
+    
+    // 首字母必须是大写字母
+    if (!/^[A-Z]/.test(name)) {
+      return false;
+    }
+    
+    // 整体必须符合标识符规范
+    if (!/^[A-Za-z][A-Za-z0-9]*$/.test(name)) {
+      return false;
     }
+    
+    return true;
+  }
 
-    // 将属性规则类型映射到对应的基础规则类型
-    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';
+  /**
+   * 检查属性名是否在作用域内有对应的类实例变量声明
+   * @param {string} name 属性名
+   * @param {object} node AST节点
+   * @returns {boolean} 是否是类实例引用
+   */
+  _isClassInstanceReference(name, node) {
+    if (!name || !node) {
+      return false;
+    }
+    
+    // 遍历AST查找变量声明
+    var current_node = node;
+    while (current_node.parent) {
+      current_node = current_node.parent;
+      
+      // 查找变量声明
+      if (current_node.type === 'VariableDeclaration') {
+        for (var i = 0; i < current_node.declarations.length; i++) {
+          var decl = current_node.declarations[i];
+          if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+            // 检查是否为类实例声明（new表达式）
+            if (decl.init && decl.init.type === 'NewExpression') {
+              return true;
+            }
+          }
+        }
       }
-      // 属性方法名 -> 方法名
-      else if (rule_type === 'property-method-name') {
-        base_rule_type = 'method-name';
+      
+      // 查找赋值表达式
+      if (current_node.type === 'AssignmentExpression' && 
+          current_node.left && current_node.left.type === 'Identifier' && 
+          current_node.left.name === name) {
+        // 检查是否为类实例赋值（new表达式）
+        if (current_node.right && current_node.right.type === 'NewExpression') {
+          return true;
+        }
       }
-      // 属性值名 -> 变量名
-      else if (rule_type === 'property-value-name') {
-        base_rule_type = 'variable-name';
+      
+      // 如果到达程序根节点，停止搜索
+      if (current_node.type === 'Program') {
+        break;
       }
     }
+    
+    return false;
+  }
 
-    // 检查忽略词
-    var ignored_words = this.config.getIgnoredWords(base_rule_type);
-    if (ignored_words && ignored_words.includes(prop_name)) {
-      return null; // 忽略词不进行命名规范检测
-    }
-
-    var rule = this.config.getRule(base_rule_type);
-    if (!rule) {
+  /**
+   * 通用类型溯源：对于导出语句中的属性，溯源其引用的类型
+   * @param {object} node 属性节点
+   * @returns {string} 溯源到的类型，无法溯源则返回null
+   */
+  _traceReferenceType(node) {
+    if (!node || !node.key || node.key.type !== 'Identifier') {
       return null;
     }
-
-    // 首先检查命名风格
-    var style_err = null;
-
-    if (rule_type === "property-value-name") {
-      // 对于属性值名，智能识别属性值类型并应用相应的命名规范
-      style_err = this._checkPropertyValueStyle(prop_name, val_node, rule_type);
-    } else if (rule_type === "property-method-name") {
-      // 属性方法：智能识别方法类型并提供准确的命名规范
-      style_err = this._checkPropertyMethodStyle(
-        prop_name,
-        val_node,
-        rule_type,
-      );
-    } else if (rule_type === "property-instance-class-name") {
-      // 属性实例类：智能识别实例类并提供准确的命名规范
-      style_err = this._checkPropertyInstanceClassStyle(
-        prop_name,
-        val_node,
-        rule_type,
-      );
-    } else if (rule_type === "property-class-name") {
-      // 属性类：智能识别类引用并提供准确的命名规范
-      style_err = this._checkPropertyClassStyle(prop_name, val_node, rule_type);
-    } else {
-      // 其他属性类型：使用原有逻辑
-      style_err = this._validate_naming_style(
-        prop_name,
-        rule.styles,
-        rule_type,
-      );
-    }
-
-    if (style_err) {
-      return {
-        node: node,
-        message: style_err,
-        rule_type: rule_type, // 添加规则类型信息
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      prop_name,
-      rule.min,
-      rule.max,
-      rule_type,
-    );
-    if (len_err) {
-      // 使用智能缩写生成推荐名称
-      var smart_abbreviation = this._getSmartAbbreviation(prop_name, rule_type);
-      var error_message = len_err;
-      if (smart_abbreviation && smart_abbreviation !== prop_name) {
-        error_message = len_err + "，建议使用: " + smart_abbreviation;
-      }
-
-      return {
-        node: node,
-        message: error_message,
-        rule_type: rule_type, // 添加规则类型信息
-      };
-    }
-
-    // 检查单词长度
-    // 对于私有属性值名（以_开头且长度>2），跳过单词长度检查，视为单个单词
-    var is_private_property = prop_name.startsWith("_");
-    if (!(is_private_property && prop_name.length > 2)) {
-      var word_err = this._checkWordLength(
-        prop_name,
-        rule.single_word_len,
-        rule_type,
-      );
-      if (word_err) {
-        // 检查错误消息是否已经包含建议
-        var error_message = word_err;
-        if (!word_err.includes("建议使用")) {
-          // 如果错误消息中不包含建议，则添加建议
-          var smart_abbreviation = this._getSmartAbbreviation(
-            prop_name,
-            rule_type,
-          );
-          if (smart_abbreviation && smart_abbreviation !== prop_name) {
-            error_message = word_err + "，建议使用: " + smart_abbreviation;
-          }
-        }
-
-        return {
-          node: node,
-          message: error_message,
-          rule_type: rule_type, // 添加规则类型信息
-        };
-      }
+    
+    // 对于简写属性 { AdminManager }，溯源属性名对应的类型
+    if (node.shorthand) {
+      return this._traceIdentifierType(node.key.name, node);
     }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(prop_name, base_rule_type);
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-        rule_type: rule_type, // 添加规则类型信息
-      };
+    
+    // 对于完整属性 { Admin_DD: Admin }，溯源属性值对应的类型
+    if (!node.shorthand && node.value && node.value.type === 'Identifier') {
+      return this._traceIdentifierType(node.value.name, node);
     }
-
-    return null;
-  } catch (error) {
-    console.error("检测属性名时出错:", error);
+    
+    // 其他情况无法溯源
     return null;
   }
-};
 
-/**
- * 检查并推荐更合适的词汇
- * @param {string} name 名称
- * @param {string} name_type 名称类型
- * @returns {string|null} 推荐信息或null
- */
-Detector.prototype._checkAndRecommend = function (name, name_type) {
-  try {
-    var rec_words = this.config.getRecommendedWords(name_type);
-    if (!rec_words || Object.keys(rec_words).length === 0) {
+  /**
+   * 溯源标识符的类型
+   * @param {string} name 标识符名
+   * @param {object} node AST节点
+   * @returns {string} 溯源到的类型，无法溯源则返回null
+   */
+  _traceIdentifierType(name, node) {
+    if (!name || !node) {
       return null;
     }
-
-    var name_lower = name.toLowerCase();
-    var is_private = name.startsWith("_");
-    var name_without_prefix = is_private ? name.substring(1) : name;
-    var name_without_prefix_lower = name_without_prefix.toLowerCase();
-
-    // 检查每个推荐词映射
-    for (var rec_word in rec_words) {
-      if (rec_words.hasOwnProperty(rec_word)) {
-        var original_words = rec_words[rec_word];
-
-        // 检查名称是否包含任何一个原词
-        for (var i = 0; i < original_words.length; i++) {
-          var original_word = original_words[i].toLowerCase();
-
-          // 检查名称（去除私有前缀后）是否包含原词
-          if (name_without_prefix_lower.includes(original_word)) {
-            // 使用智能缩写生成完整的推荐名称
-            var smart_abbreviation = this._getSmartAbbreviation(
-              name,
-              name_type,
-            );
-            var recommended_name =
-              smart_abbreviation && smart_abbreviation !== name
-                ? smart_abbreviation
-                : name;
-
-            return {
-              type: "recommendation",
-              message:
-                "建议使用'" +
-                recommended_name +
-                "'替代'" +
-                name +
-                "'以获得更简洁的命名",
-              recommended_name: recommended_name,
-              original_name: name,
-              original_word: original_words[i],
-              recommended_word: rec_word,
-            };
+    
+    // 获取Program节点（AST根节点）
+    var program_node = this._getProgramNode(node);
+    if (!program_node || !program_node.body) {
+      return null;
+    }
+    
+    // 遍历同级节点查找声明
+    for (var i = 0; i < program_node.body.length; i++) {
+      var sibling_node = program_node.body[i];
+      
+      // 查找类声明
+      if (sibling_node.type === 'ClassDeclaration') {
+        if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
+          return 'class';
+        }
+      }
+      
+      // 查找函数声明
+      if (sibling_node.type === 'FunctionDeclaration') {
+        if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
+          return 'function';
+        }
+      }
+      
+      // 查找变量声明
+      if (sibling_node.type === 'VariableDeclaration') {
+        for (var j = 0; j < sibling_node.declarations.length; j++) {
+          var decl = sibling_node.declarations[j];
+          if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+            // 检查变量声明的类型
+            if (decl.init) {
+              // 类表达式
+              if (decl.init.type === 'ClassExpression') {
+                return 'class';
+              }
+              
+              // 函数表达式
+              if (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression') {
+                return 'function';
+              }
+              
+              // new 表达式（类实例）
+              if (decl.init.type === 'NewExpression') {
+                return 'class-instance';
+              }
+              
+              // 常量（只有const声明且为基础字面量）
+              if (sibling_node.kind === 'const' && this._isBasicLiteralValue(decl.init)) {
+                return 'constant';
+              }
+              
+              // 普通变量
+              return 'variable';
+            }
+            
+            // 没有初始值的变量声明，默认为变量
+            return 'variable';
           }
         }
       }
     }
-
-    return null;
-  } catch (error) {
-    console.error("检查并推荐更合适的词汇时出错:", error);
+    
+    // 无法溯源到具体类型
     return null;
   }
-};
 
-/**
- * 检查值是否为基础值类型
- * @param {object} val_node 值节点
- * @returns {boolean} 是否为基础值
- */
-Detector.prototype._isBaseValue = function (val_node) {
-  try {
-    if (!val_node) {
+  /**
+   * 检查属性名是否在作用域内有对应的类声明
+   * @param {string} name 属性名
+   * @param {object} node AST节点
+   * @returns {boolean} 是否是类引用
+   */
+  _isClassReference(name, node) {
+    if (!name || !node) {
       return false;
     }
-
-    // 检查是否为基础值类型
-    var is_base_value = false;
-
-    switch (val_node.type) {
-      case "Literal": // 字面量：数字、字符串、布尔值
-        is_base_value = true;
-        break;
-      case "ArrayExpression": // 数组字面量
-        is_base_value = true;
-        break;
-      case "ObjectExpression": // 对象字面量
-        is_base_value = true;
-        break;
-      case "UnaryExpression": // 一元表达式（如 -1, +100）
-        if (val_node.operator === "-" || val_node.operator === "+") {
-          is_base_value = true;
+    
+    console.log('  [DEBUG] _isClassReference called:', name);
+    
+    // 在ESLint环境中，AST节点有parent属性，可以向上遍历
+    // 获取Program节点（AST根节点）
+    var program_node = this._getProgramNode(node);
+    console.log('  [DEBUG] Program node:', program_node ? program_node.type : 'null');
+    
+    if (!program_node || !program_node.body) {
+      console.log('  [DEBUG] No program node or body');
+      return false;
+    }
+    
+    console.log('  [DEBUG] Program body length:', program_node.body.length);
+    
+    // 遍历同级节点查找类声明
+    for (var i = 0; i < program_node.body.length; i++) {
+      var sibling_node = program_node.body[i];
+      console.log('  [DEBUG] Sibling node', i, ':', sibling_node.type);
+      
+      // 查找类声明
+      if (sibling_node.type === 'ClassDeclaration') {
+        console.log('  [DEBUG] Found ClassDeclaration:', sibling_node.id ? sibling_node.id.name : 'null');
+        if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
+          console.log('  [DEBUG] Class reference found!');
+          return true;
         }
-        break;
-      default:
-        is_base_value = false;
+      }
+      
+      // 查找变量声明中的类表达式
+      if (sibling_node.type === 'VariableDeclaration') {
+        for (var j = 0; j < sibling_node.declarations.length; j++) {
+          var decl = sibling_node.declarations[j];
+          if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+            // 检查是否为类表达式
+            if (decl.init && decl.init.type === 'ClassExpression') {
+              return true;
+            }
+          }
+        }
+      }
     }
-
-    return is_base_value;
-  } catch (error) {
-    console.error("检查值是否为基础值类型时出错:", error);
+    
+    console.log('  [DEBUG] No class reference found');
     return false;
   }
-};
-
-/**
- * 检查是否应该使用let而不是const声明变量
- * @param {object} node 变量声明节点
- * @param {object} val_node 值节点
- * @returns {boolean} 是否应该使用let
- */
-Detector.prototype._shouldUseLetInsteadOfConst = function (node, val_node) {
-  try {
-    if (!node || !val_node) {
-      return false;
-    }
-
-    // 检查是否为模块导入（需要排除的情况）
-    var is_module_import = this._isModuleImport(node, val_node);
-    if (is_module_import) {
-      return false;
-    }
 
-    // 检查是否为解构赋值
-    var is_destructuring = false;
-    if (node.parent && node.parent.type === "VariableDeclarator") {
-      var declarator = node.parent;
-      if (
-        declarator.id &&
-        (declarator.id.type === "ObjectPattern" ||
-          declarator.id.type === "ArrayPattern")
-      ) {
-        is_destructuring = true;
+  /**
+   * 获取Program节点（AST根节点）
+   * @param {object} node AST节点
+   * @returns {object} Program节点
+   */
+  _getProgramNode(node) {
+    var current_node = node;
+    
+    // 在ESLint环境中，AST节点有parent属性，可以向上遍历
+    // 向上遍历直到找到Program节点
+    while (current_node && current_node.parent) {
+      current_node = current_node.parent;
+      
+      // 如果找到Program节点，返回它
+      if (current_node.type === 'Program') {
+        return current_node;
       }
     }
+    
+    // 如果没有找到Program节点，返回null
+    return null;
+  }
 
-    // 应该使用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;
-    }
+  /**
+   * 获取父级声明类型
+   * @param {object} node AST节点
+   * @returns {string} 声明类型
+   */
+  _getParentDeclarationType(node) {
+    var current_node = node;
 
-    return should_use_let;
-  } catch (error) {
-    console.error("检查是否应该使用let时出错:", error);
-    return false;
-  }
-};
+    while (current_node.parent) {
+      current_node = current_node.parent;
 
-/**
- * 检查值是否为复杂类型（方法、函数、实例等）
- * @param {object} val_node 值节点
- * @returns {boolean} 是否为复杂类型
- */
-Detector.prototype._isComplexType = function (val_node) {
-  try {
-    if (!val_node) {
-      return false;
-    }
+      if (current_node.type === 'VariableDeclarator' && current_node.parent && current_node.parent.kind) {
+        return current_node.parent.kind;
+      }
 
-    // 检查是否为复杂类型
-    var is_complex_type = false;
-
-    switch (val_node.type) {
-      case "FunctionExpression": // 函数表达式
-      case "ArrowFunctionExpression": // 箭头函数
-      case "NewExpression": // new 实例化
-      case "CallExpression": // 函数调用
-      case "MemberExpression": // 成员表达式
-      case "Identifier": // 标识符（可能是变量或函数）
-      case "ClassExpression": // 类表达式
-      case "ThisExpression": // this表达式
-      case "TemplateLiteral": // 模板字符串
-        is_complex_type = true;
-        break;
-      default:
-        is_complex_type = false;
+      if (current_node.type === 'AssignmentExpression') {
+        return 'variable';
+      }
     }
 
-    return is_complex_type;
-  } catch (error) {
-    console.error("检查值是否为复杂类型时出错:", error);
-    return false;
+    return 'unknown';
   }
-};
 
-/**
- * 检查是否为模块导入（需要排除const检测的情况）
- * @param {object} node 变量声明节点
- * @param {object} val_node 值节点
- * @returns {boolean} 是否为模块导入
- */
-Detector.prototype._isModuleImport = function (node, val_node) {
-  try {
-    if (!node || !val_node) {
-      return false;
-    }
+  /**
+   * 获取父级对象节点
+   * @param {object} node AST节点
+   * @returns {object|null} 父级对象节点
+   */
+  _getParentObject(node) {
+    var current_node = node;
 
-    // 情况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;
-      }
+    while (current_node.parent) {
+      current_node = current_node.parent;
 
-      // 检查是否为import()动态导入
-      if (val_node.callee.type === "Import") {
-        return true;
+      if (current_node.type === 'ObjectExpression') {
+        return current_node;
       }
-    }
-
-    // 情况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;
-          }
-        }
+      if (current_node.type === 'VariableDeclarator' || current_node.type === 'AssignmentExpression') {
+        break;
       }
     }
 
-    return false;
-  } catch (error) {
-    console.error("检查是否为模块导入时出错:", error);
-    return false;
+    return null;
   }
-};
 
-/**
- * 检查标识符是否为模块导入变量
- * @param {object} node AST节点（Identifier类型）
- * @returns {boolean} 是否为模块导入变量
- */
-Detector.prototype._isModuleImportVariable = function (node) {
-  try {
-    if (!node || node.type !== "Identifier") {
+  /**
+   * 判断是否为基础字面量值（排除正则表达式）
+   * @param {object} node AST节点
+   * @returns {boolean} 是否为基础字面量
+   */
+  _isBasicLiteralValue(node) {
+    if (!node) {
       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;
+    switch (node.type) {
+      case 'Literal':
+        // 排除正则表达式
+        return !node.regex;
+      case 'TemplateLiteral':
+        return true;
+      case 'ArrayExpression':
+        // 数组必须所有元素都是基础字面量
+        if (node.elements && node.elements.length > 0) {
+          for (var i = 0; i < node.elements.length; i++) {
+            if (!this._isBasicLiteralValue(node.elements[i])) {
+              return false;
             }
           }
         }
-      }
+        return true;
+      case 'ObjectExpression':
+        // 对象必须所有属性值都是基础字面量
+        if (node.properties && node.properties.length > 0) {
+          for (var i = 0; i < node.properties.length; i++) {
+            var property = node.properties[i];
+            if (property.value && !this._isBasicLiteralValue(property.value)) {
+              return false;
+            }
+          }
+        }
+        return true;
+      case 'Identifier':
+        var basic_literal_identifiers = ['undefined', 'null', 'Infinity', 'NaN', 'true', 'false'];
+        return basic_literal_identifiers.includes(node.name);
+      default:
+        return false;
     }
-
-    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) {
+  /**
+   * 检查对象的所有属性是否都是字面量
+   * @param {object} object_node 对象节点
+   * @returns {boolean} 是否所有属性都是字面量
+   */
+  _isObjectAllLiteral(object_node) {
+    if (object_node.type !== 'ObjectExpression' || !object_node.properties) {
       return false;
     }
 
-    // 检查是否为解构导入模式
-    var is_destructured = false;
-
-    // 情况1：节点是Property.key（解构赋值中的属性键）
-    if (node.parent.type === "Property" && node.parent.key === node) {
-      var property = node.parent;
-
-      // 检查Property的父节点是否为ObjectPattern
-      if (property.parent && property.parent.type === "ObjectPattern") {
-        var object_pattern = property.parent;
+    for (var i = 0; i < object_node.properties.length; i++) {
+      var property = object_node.properties[i];
 
-        // 检查ObjectPattern的父节点是否为VariableDeclarator
-        if (
-          object_pattern.parent &&
-          object_pattern.parent.type === "VariableDeclarator"
-        ) {
-          var declarator = object_pattern.parent;
-
-          // 检查右侧是否为require调用或其他模块导入
-          if (declarator.init) {
-            var init_type = declarator.init.type;
-
-            // 常见的模块导入方式
-            if (
-              init_type === "CallExpression" &&
-              declarator.init.callee &&
-              declarator.init.callee.name === "require"
-            ) {
-              is_destructured = true;
-            }
+      // 跳过解构赋值
+      if (property.type !== 'Property') {
+        continue;
+      }
 
-            // 如果是ImportDeclaration（ES6导入）
-            if (init_type === "ImportExpression") {
-              is_destructured = true;
-            }
-          }
-        }
+      // 检查属性值是否为字面量
+      if (!this._isLiteralValue(property.value)) {
+        return false;
       }
     }
 
-    // 情况2：节点是VariableDeclarator（简单变量声明）
-    else if (node.parent.type === "VariableDeclarator") {
-      var declarator = node.parent;
-
-      // 检查是否为解构模式（ObjectPattern或ArrayPattern）
-      if (declarator.id && declarator.id.type === "ObjectPattern") {
-        // 检查右侧是否为require调用或其他模块导入
-        if (declarator.init) {
-          var init_type = declarator.init.type;
-
-          // 常见的模块导入方式
-          if (
-            init_type === "CallExpression" &&
-            declarator.init.callee &&
-            declarator.init.callee.name === "require"
-          ) {
-            is_destructured = true;
-          }
-
-          // 如果是ImportDeclaration（ES6导入）
-          if (init_type === "ImportExpression") {
-            is_destructured = true;
-          }
-        }
-      }
-    }
-
-    return is_destructured;
-  } catch (error) {
-    console.error("检查是否为解构导入时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为解构导入中的属性
- * @param {object} node 属性节点
- * @param {object} parent_node 父节点
- * @returns {boolean} 是否为解构导入中的属性
- */
-Detector.prototype._isDestructuredImportProperty = function (
-  node,
-  parent_node,
-) {
-  try {
-    // 处理新的父节点信息结构（包含node和parent属性）
-    var actual_parent_node = parent_node;
-    if (parent_node && typeof parent_node === "object" && parent_node.node) {
-      actual_parent_node = parent_node.node;
-    }
-
-    if (!node || !actual_parent_node) {
-      return false;
-    }
-
-    // 检查父节点是否为ObjectPattern（解构模式）
-    if (actual_parent_node.type === "ObjectPattern") {
-      // 检查父节点的父节点是否为VariableDeclarator
-      var actual_parent_parent =
-        parent_node && typeof parent_node === "object" && parent_node.parent
-          ? parent_node.parent
-          : actual_parent_node.parent;
-
-      if (
-        actual_parent_parent &&
-        actual_parent_parent.type === "VariableDeclarator"
-      ) {
-        var declarator = actual_parent_parent;
-
-        // 检查右侧是否为require调用或其他模块导入
-        if (declarator.init) {
-          var init_type = declarator.init.type;
-
-          // 常见的模块导入方式
-          if (
-            init_type === "CallExpression" &&
-            declarator.init.callee &&
-            declarator.init.callee.name === "require"
-          ) {
-            return true;
-          }
-
-          // 如果是ImportDeclaration（ES6导入）
-          if (init_type === "ImportExpression") {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为解构导入中的属性时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为函数赋值（函数表达式或箭头函数）
- * @param {object} node AST节点
- * @returns {boolean} 是否为函数赋值
- */
-Detector.prototype._isFunctionAssignment = function (node) {
-  try {
-    if (!node) {
-      return false;
-    }
-
-    // 检查节点是否为解构赋值中的属性
-    if (node.type === "Property" && node.key === node) {
-      // 检查父节点是否为ObjectPattern
-      if (node.parent && node.parent.type === "ObjectPattern") {
-        // 检查父节点的父节点是否为VariableDeclarator
-        if (
-          node.parent.parent &&
-          node.parent.parent.type === "VariableDeclarator"
-        ) {
-          var declarator = node.parent.parent;
-
-          // 检查右侧是否为函数表达式或箭头函数
-          if (declarator.init) {
-            var init_type = declarator.init.type;
-
-            // 函数表达式
-            if (init_type === "FunctionExpression") {
-              return true;
-            }
-
-            // 箭头函数
-            if (init_type === "ArrowFunctionExpression") {
-              return true;
-            }
-
-            // 函数调用（可能返回函数）
-            if (init_type === "CallExpression") {
-              return true;
-            }
-          }
-        }
-      }
-    }
-
-    // 检查节点是否为解构赋值中的数组元素
-    if (
-      node.type === "Identifier" &&
-      node.parent &&
-      node.parent.type === "ArrayPattern"
-    ) {
-      // 检查父节点的父节点是否为VariableDeclarator
-      if (
-        node.parent.parent &&
-        node.parent.parent.type === "VariableDeclarator"
-      ) {
-        var declarator = node.parent.parent;
-
-        // 检查右侧是否为函数表达式或箭头函数
-        if (declarator.init) {
-          var init_type = declarator.init.type;
-
-          // 函数表达式
-          if (init_type === "FunctionExpression") {
-            return true;
-          }
-
-          // 箭头函数
-          if (init_type === "ArrowFunctionExpression") {
-            return true;
-          }
-
-          // 函数调用（可能返回函数）
-          if (init_type === "CallExpression") {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为函数赋值时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查常量名是否符合规范
- * @param {string} constant_name 常量名
- * @returns {boolean} 是否符合规范
- */
-Detector.prototype._isConstantNameValid = function (constant_name) {
-  try {
-    var rule = this.config.getRule("constant-name");
-    if (!rule) {
-      return false;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      constant_name,
-      rule.styles,
-      "constant-name",
-    );
-    return !style_err;
-  } catch (error) {
-    console.error("检查常量名是否符合规范时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检查是否为忽略词
- * @param {string} name 名称
- * @param {string} name_type 名称类型
- * @returns {boolean} 是否为忽略词
- */
-Detector.prototype._isIgnoredWord = function (name, name_type) {
-  try {
-    var ignored_words = this.config.getIgnoredWords(name_type);
-    if (!ignored_words || !Array.isArray(ignored_words)) {
-      return false;
-    }
-
-    var name_lower = name.toLowerCase();
-    for (var i = 0; i < ignored_words.length; i++) {
-      if (ignored_words[i].toLowerCase() === name_lower) {
-        return true;
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为忽略词时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 生成推荐命名
- * @param {string} original_name 原始名称
- * @param {string} long_word 过长的单词
- * @param {string} name_type 名称类型
- * @returns {string|null} 推荐命名或null
- */
-Detector.prototype._generateRecommendedName = function (
-  original_name,
-  long_word,
-  name_type,
-) {
-  try {
-    // 获取推荐词映射
-    var recommended_words = this.config.getRecommendedWords(name_type);
-    if (!recommended_words || Object.keys(recommended_words).length === 0) {
-      return null;
-    }
-
-    var long_word_lower = long_word.toLowerCase();
-    var is_private = original_name.startsWith("_");
-    var original_name_without_prefix = is_private
-      ? original_name.substring(1)
-      : original_name;
-
-    // 检查推荐词映射中是否有对应的缩写
-    for (var short_word in recommended_words) {
-      if (recommended_words.hasOwnProperty(short_word)) {
-        var original_words = recommended_words[short_word];
-
-        // 检查过长的单词是否在推荐词的原词列表中
-        for (var i = 0; i < original_words.length; i++) {
-          var original_word = original_words[i].toLowerCase();
-          if (long_word_lower === original_word) {
-            // 生成推荐命名：将原始名称中的长单词替换为推荐的缩写，保持私有前缀
-            var recommended_name_without_prefix =
-              original_name_without_prefix.replace(long_word, short_word);
-            var recommended_name = is_private
-              ? "_" + recommended_name_without_prefix
-              : recommended_name_without_prefix;
-            return recommended_name;
-          }
-        }
-      }
-    }
-
-    return null;
-  } catch (error) {
-    console.error("生成推荐命名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 转换命名风格
- * @param {string} name 原始名称
- * @param {string} target_style 目标命名风格
- * @param {string} name_type 名称类型
- * @returns {string} 转换后的名称
- */
-Detector.prototype._convertNamingStyle = function (
-  name,
-  target_style,
-  name_type,
-) {
-  try {
-    if (!name || !target_style) {
-      return name;
-    }
-
-    // 处理私有标识符
-    var has_private_prefix = name.startsWith("_");
-    var processed_name = has_private_prefix ? name.substring(1) : name;
-
-    // 分割单词
-    var words = this._splitNameIntoWords(processed_name);
-
-    // 过滤空字符串和私有标识符
-    words = words.filter(function (word) {
-      return word && word.length > 0 && word !== "_";
-    });
-
-    if (words.length === 0) {
-      return name;
-    }
-
-    var converted_name = "";
-
-    // 根据目标风格转换
-    switch (target_style) {
-      case "camelCase":
-        // 小驼峰命名法
-        converted_name = words
-          .map(function (word, index) {
-            if (index === 0) {
-              return word.toLowerCase();
-            }
-            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-          })
-          .join("");
-        break;
-
-      case "_camelCase":
-        // 私有小驼峰命名法
-        converted_name =
-          "_" +
-          words
-            .map(function (word, index) {
-              if (index === 0) {
-                return word.toLowerCase();
-              }
-              return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-            })
-            .join("");
-        break;
-
-      case "PascalCase":
-        // 大驼峰命名法
-        converted_name = words
-          .map(function (word) {
-            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-          })
-          .join("");
-        break;
-
-      case "snake_case":
-        // 小写蛇形命名法
-        converted_name = words
-          .map(function (word) {
-            return word.toLowerCase();
-          })
-          .join("_");
-        break;
-
-      case "_snake_case":
-        // 私有小写蛇形命名法
-        converted_name =
-          "_" +
-          words
-            .map(function (word) {
-              return word.toLowerCase();
-            })
-            .join("_");
-        break;
-
-      case "UPPER_SNAKE_CASE":
-        // 大写蛇形命名法
-        converted_name = words
-          .map(function (word) {
-            return word.toUpperCase();
-          })
-          .join("_");
-        break;
-
-      default:
-        converted_name = name;
-    }
-
-    // 如果原始名称有私有前缀但目标风格不是私有风格，则添加私有前缀
-    if (
-      has_private_prefix &&
-      !target_style.startsWith("_") &&
-      !converted_name.startsWith("_")
-    ) {
-      converted_name = "_" + converted_name;
-    }
-
-    return converted_name;
-  } catch (error) {
-    console.error("转换命名风格时出错:", error);
-    return name;
-  }
-};
-
-/**
- * 获取命名修复建议
- * @param {string} name 原始名称
- * @param {string} name_type 名称类型
- * @param {string} error_message 错误信息
- * @returns {object|null} 修复建议对象
- */
-Detector.prototype._getFixSuggestion = function (
-  name,
-  name_type,
-  error_message,
-) {
-  try {
-    var rule = this.config.getRule(name_type);
-    if (!rule || !rule.styles || rule.styles.length === 0) {
-      return null;
-    }
-
-    // 根据名称类型智能选择目标风格
-    var target_style = this._getSmartTargetStyle(name, name_type, rule.styles);
-
-    // 生成修复后的名称
-    var fixed_name = this._convertNamingStyle(name, target_style, name_type);
-
-    // 优先检查错误消息中是否有建议使用的名称
-    if (error_message && error_message.includes("建议使用:")) {
-      // 从错误消息中提取建议的名称
-      var suggestion_match = error_message.match(/建议使用:\s*([\w_]+)/);
-      if (suggestion_match && suggestion_match[1]) {
-        fixed_name = suggestion_match[1];
-
-        // 对于私有方法（以_开头），根据错误消息确定正确的命名风格
-        if (name_type === "method-name" && fixed_name.startsWith("_")) {
-          // 检查错误消息中是否指定了命名风格
-          if (error_message.includes("_camelCase")) {
-            target_style = "_camelCase";
-          } else if (error_message.includes("_snake_case")) {
-            target_style = "_snake_case";
-          } else {
-            // 默认使用_snake_case风格
-            target_style = "_snake_case";
-          }
-        }
-
-        // 验证建议的名称是否有效
-        var suggestion_validation = this._validate_naming_style(
-          fixed_name,
-          [target_style],
-          name_type,
-        );
-
-        if (suggestion_validation) {
-          // 建议的名称无效，回退到原始转换逻辑
-          fixed_name = this._convertNamingStyle(name, target_style, name_type);
-        }
-      }
-    }
-
-    // 检查是否需要智能缩写（长度过长的问题）
-    if (error_message && error_message.includes("长度过长")) {
-      // 如果错误消息中已经有建议名称，使用建议名称
-      if (error_message.includes("建议使用:")) {
-        // 已经处理过建议名称，直接使用
-      } else {
-        // 如果没有建议名称，使用智能缩写
-        fixed_name = this._getSmartAbbreviation(name, name_type);
-
-        // 如果智能缩写后名称仍然相同，则不提供修复建议
-        if (fixed_name === name) {
-          return null;
-        }
-
-        // 支持多次缩写直到满足长度要求
-        var max_length = rule.max || 20;
-        var current_name = fixed_name;
-        var max_attempts = 5; // 最多尝试5次
-
-        for (var attempt = 0; attempt < max_attempts; attempt++) {
-          if (current_name.length <= max_length) {
-            break; // 长度满足要求，退出循环
-          }
-
-          var next_name = this._getSmartAbbreviation(current_name, name_type);
-          if (next_name === current_name) {
-            break; // 无法进一步缩写，退出循环
-          }
-          current_name = next_name;
-        }
-
-        fixed_name = current_name;
-      }
-    } else if (fixed_name === name) {
-      // 其他情况下，转换后名称相同，不提供修复建议
-      return null;
-    }
-
-    // 检查修复后的名称是否仍然有错误
-    var fixed_style_err = this._validate_naming_style(
-      fixed_name,
-      [target_style],
-      name_type,
-    );
-    if (fixed_style_err) {
-      // 修复后的名称仍然有错误，尝试其他风格
-      for (var i = 1; i < rule.styles.length; i++) {
-        var alternative_style = rule.styles[i];
-        var alternative_name = this._convertNamingStyle(
-          name,
-          alternative_style,
-          name_type,
-        );
-        var alternative_err = this._validate_naming_style(
-          alternative_name,
-          [alternative_style],
-          name_type,
-        );
-
-        if (!alternative_err) {
-          fixed_name = alternative_name;
-          target_style = alternative_style;
-          break;
-        }
-      }
-    }
-
-    // 如果名称长度仍然过长，且错误消息中没有建议名称，进行智能缩写处理
-    if (
-      error_message &&
-      error_message.includes("长度过长") &&
-      !error_message.includes("建议使用:")
-    ) {
-      fixed_name = this._getSmartAbbreviation(name, name_type);
-    }
-
-    return {
-      fixed_name: fixed_name,
-      target_style: target_style,
-    };
-  } catch (error) {
-    console.error("获取命名修复建议时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 智能缩写处理（针对长度过长的名称）
- * @param {string} name 原始名称
- * @param {string} name_type 名称类型
- * @returns {string} 缩写后的名称
- */
-Detector.prototype._getSmartAbbreviation = function (name, name_type) {
-  try {
-    // 处理私有标识符
-    var has_private_prefix = name.startsWith("_");
-    var processed_name = has_private_prefix ? name.substring(1) : name;
-
-    // 分割单词
-    var words = this._splitNameIntoWords(processed_name);
-
-    // 过滤空字符串
-    words = words.filter(function (word) {
-      return word && word.length > 0;
-    });
-
-    if (words.length === 0) {
-      return name;
-    }
-
-    // 获取配置中的推荐词映射
-    var rec_words = {};
-    if (
-      this.config.getRecommendedWords &&
-      typeof this.config.getRecommendedWords === "function"
-    ) {
-      rec_words = this.config.getRecommendedWords(name_type);
-    }
-
-    // 获取配置中的禁止词列表（作为禁止拼接词）
-    var forbidden_words = [];
-    if (
-      this.config.getForbiddenWords &&
-      typeof this.config.getForbiddenWords === "function"
-    ) {
-      forbidden_words = this.config.getForbiddenWords(name_type);
-    }
-
-    if (!rec_words || Object.keys(rec_words).length === 0) {
-      return name;
-    }
-
-    // 处理每个单词，使用推荐词替换
-    var processed_words = [];
-    for (var i = 0; i < words.length; i++) {
-      var word = words[i];
-      var word_lower = word.toLowerCase();
-      var replaced = false;
-
-      // 检查是否需要替换为推荐词
-      for (var rec_word in rec_words) {
-        if (rec_words.hasOwnProperty(rec_word)) {
-          var original_words = rec_words[rec_word];
-
-          for (var j = 0; j < original_words.length; j++) {
-            var original_word = original_words[j].toLowerCase();
-
-            // 如果当前单词包含原词（不区分大小写），则替换为推荐词
-            if (word_lower.includes(original_word)) {
-              // 保持首字母大小写
-              if (word[0] === word[0].toUpperCase()) {
-                processed_words.push(
-                  rec_word[0].toUpperCase() + rec_word.substring(1),
-                );
-              } else {
-                processed_words.push(rec_word);
-              }
-              replaced = true;
-              break;
-            }
-          }
-
-          if (replaced) break;
-        }
-      }
-
-      // 如果没有找到推荐词，检查是否为禁止拼接词
-      if (!replaced) {
-        var is_forbidden = false;
-        for (var f = 0; f < forbidden_words.length; f++) {
-          var forbidden_word = forbidden_words[f].toLowerCase();
-          if (word_lower === forbidden_word) {
-            is_forbidden = true;
-            break;
-          }
-        }
-
-        // 如果不是禁止拼接词，保留原词
-        if (!is_forbidden) {
-          processed_words.push(word);
-        }
-      }
-    }
-
-    // 根据名称类型确定目标风格
-    var target_style = "camelCase";
-    if (name_type === "constant-name") {
-      target_style = "UPPER_SNAKE_CASE";
-    } else if (
-      name_type === "class-name" ||
-      name_type === "property-class-name"
-    ) {
-      target_style = "PascalCase";
-    } else if (
-      name_type === "variable-name" ||
-      name_type === "property-value-name"
-    ) {
-      target_style = "snake_case";
-    }
-    // 函数名、方法名等保持默认的 camelCase
-
-    var abbreviated_name = "";
-
-    switch (target_style) {
-      case "camelCase":
-        for (var k = 0; k < processed_words.length; k++) {
-          if (k === 0) {
-            abbreviated_name += processed_words[k].toLowerCase();
-          } else {
-            abbreviated_name +=
-              processed_words[k][0].toUpperCase() +
-              processed_words[k].substring(1).toLowerCase();
-          }
-        }
-        break;
-      case "PascalCase":
-        for (var l = 0; l < processed_words.length; l++) {
-          abbreviated_name +=
-            processed_words[l][0].toUpperCase() +
-            processed_words[l].substring(1).toLowerCase();
-        }
-        break;
-      case "snake_case":
-        abbreviated_name = processed_words.join("_").toLowerCase();
-        break;
-      case "UPPER_SNAKE_CASE":
-        abbreviated_name = processed_words.join("_").toUpperCase();
-        break;
-      default:
-        abbreviated_name = processed_words.join("");
-    }
-
-    // 恢复私有标识符
-    if (has_private_prefix) {
-      abbreviated_name = "_" + abbreviated_name;
-    }
-
-    // 检查长度：如果缩写后长度没有变短，尝试其他策略
-    if (abbreviated_name.length >= name.length) {
-      return name;
-    }
-
-    // 如果缩写后仍然超过最大长度，尝试进一步优化
-    var max_length = 20;
-    if (abbreviated_name.length > max_length) {
-      // 策略1: 截断过长的单词
-      var optimized_words = [];
-      for (var k = 0; k < processed_words.length; k++) {
-        var word = processed_words[k];
-        if (word.length > 8) {
-          // 截断过长的单词到8个字符
-          optimized_words.push(word.substring(0, 8));
-        } else {
-          optimized_words.push(word);
-        }
-      }
-
-      // 重新生成名称
-      var optimized_name = "";
-      switch (target_style) {
-        case "camelCase":
-          for (var m = 0; m < optimized_words.length; m++) {
-            if (m === 0) {
-              optimized_name += optimized_words[m].toLowerCase();
-            } else {
-              optimized_name +=
-                optimized_words[m][0].toUpperCase() +
-                optimized_words[m].substring(1).toLowerCase();
-            }
-          }
-          break;
-        case "PascalCase":
-          for (var n = 0; n < optimized_words.length; n++) {
-            optimized_name +=
-              optimized_words[n][0].toUpperCase() +
-              optimized_words[n].substring(1).toLowerCase();
-          }
-          break;
-        case "snake_case":
-          optimized_name = optimized_words.join("_").toLowerCase();
-          break;
-        case "UPPER_SNAKE_CASE":
-          optimized_name = optimized_words.join("_").toUpperCase();
-          break;
-        default:
-          optimized_name = optimized_words.join("");
-      }
-
-      // 恢复私有标识符
-      if (has_private_prefix) {
-        optimized_name = "_" + optimized_name;
-      }
-
-      // 如果优化后名称更短，使用优化后的名称
-      if (optimized_name.length < abbreviated_name.length) {
-        abbreviated_name = optimized_name;
-      }
-
-      // 如果仍然超过长度，尝试移除不重要的单词
-      if (abbreviated_name.length > max_length && processed_words.length > 2) {
-        // 保留前2个和后1个单词
-        var important_words = [
-          processed_words[0],
-          processed_words[1],
-          processed_words[processed_words.length - 1],
-        ];
-        
-        // 根据目标风格生成简化名称
-        var simplified_name = "";
-        switch (target_style) {
-          case "camelCase":
-            for (var o = 0; o < important_words.length; o++) {
-              if (o === 0) {
-                simplified_name += important_words[o].toLowerCase();
-              } else {
-                simplified_name +=
-                  important_words[o][0].toUpperCase() +
-                  important_words[o].substring(1).toLowerCase();
-              }
-            }
-            break;
-          case "PascalCase":
-            for (var p = 0; p < important_words.length; p++) {
-              simplified_name +=
-                important_words[p][0].toUpperCase() +
-                important_words[p].substring(1).toLowerCase();
-            }
-            break;
-          case "snake_case":
-            simplified_name = important_words.join("_").toLowerCase();
-            break;
-          case "UPPER_SNAKE_CASE":
-            simplified_name = important_words.join("_").toUpperCase();
-            break;
-          default:
-            simplified_name = important_words.join("");
-        }
-
-        // 恢复私有标识符
-        if (has_private_prefix) {
-          simplified_name = "_" + simplified_name;
-        }
-
-        // 如果简化后名称更短且不超过最大长度，使用简化后的名称
-        if (
-          simplified_name.length <= max_length &&
-          simplified_name.length < abbreviated_name.length
-        ) {
-          abbreviated_name = simplified_name;
-        }
-      }
-    }
-
-    return abbreviated_name;
-  } catch (error) {
-    console.error("智能缩写处理时出错:", error);
-    return name;
-  }
-};
-
-/**
- * 智能选择目标命名风格
- * @param {string} name 原始名称
- * @param {string} name_type 名称类型
- * @param {array} available_styles 可用的命名风格
- * @returns {string} 目标命名风格
- */
-Detector.prototype._getSmartTargetStyle = function (
-  name,
-  name_type,
-  available_styles,
-) {
-  try {
-    // 默认使用第一个风格
-    var target_style = available_styles[0];
-
-    // 根据名称类型和原始名称特征智能选择
-    switch (name_type) {
-      case "property-value-name":
-        // 属性值：根据是否为私有属性和值类型选择风格
-        if (name.startsWith("_")) {
-          // 私有属性值：优先使用私有蛇形命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "_snake_case";
-            }) || target_style;
-        } else {
-          // 公开属性值：优先使用蛇形命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "snake_case";
-            }) || target_style;
-        }
-        break;
-
-      case "property-class-name":
-        // 属性类：根据是否为私有类选择风格
-        if (name.startsWith("_")) {
-          // 私有属性类：优先使用私有大驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "_PascalCase";
-            }) || target_style;
-        } else {
-          // 公开属性类：优先使用大驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "PascalCase";
-            }) || target_style;
-        }
-        break;
-
-      case "property-instance-class-name":
-      case "property-method-name":
-        // 属性实例类和属性方法：根据是否为私有选择风格
-        if (name.startsWith("_")) {
-          // 私有实例类/方法：优先使用私有小驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "_camelCase";
-            }) || target_style;
-        } else {
-          // 公开实例类/方法：优先使用小驼峰命名
-          target_style =
-            available_styles.find(function (style) {
-              return style === "camelCase";
-            }) || target_style;
-        }
-        break;
-
-      default:
-        // 其他类型：使用默认风格
-        target_style = available_styles[0];
-    }
-
-    return target_style;
-  } catch (error) {
-    console.error("智能选择目标命名风格时出错:", error);
-    return available_styles[0];
-  }
-};
-
-/**
- * 检测解构赋值中的常量名
- * @param {string} constant_name 常量名
- * @param {object} node AST节点
- * @returns {object|null} 错误信息或null
- */
-Detector.prototype._checkConstantNameForDestructuring = function (
-  constant_name,
-  node,
-) {
-  try {
-    // 解构赋值中的变量应该使用变量规则，而不是常量规则
-    var rule = this.config.getRule("variable-name");
-    if (!rule) {
-      return null;
-    }
-
-    // 检查是否为忽略词
-    if (this._isIgnoredWord(constant_name, "variable-name")) {
-      return null;
-    }
-
-    // 检查是否为解构导入（从模块导入的变量）
-    var is_destructured_import = this._isDestructuredImport(node);
-
-    // 如果是解构导入，则不进行变量检测
-    if (is_destructured_import) {
-      return null;
-    }
-
-    // 检查是否为函数赋值（函数表达式或箭头函数）
-    var is_function_assignment = this._isFunctionAssignment(node);
-
-    // 如果是函数赋值，允许camelCase命名风格
-    var allowed_styles = [];
-    if (is_function_assignment) {
-      allowed_styles = ["camelCase", "UPPER_SNAKE_CASE"];
-    } else {
-      allowed_styles = rule.styles;
-    }
-
-    // 检查命名风格
-    var style_err = this._validate_naming_style(
-      constant_name,
-      allowed_styles,
-      "variable-name",
-    );
-    if (style_err) {
-      return {
-        node: node,
-        message: style_err,
-      };
-    }
-
-    // 检查并推荐更合适的词汇（作为命名风格检查的补充）
-    var recommend_info = this._checkAndRecommend(
-      constant_name,
-      "variable-name",
-    );
-    if (recommend_info) {
-      // 如果有推荐建议，在错误消息中提示可以使用更简洁的词汇
-      return {
-        node: node,
-        message:
-          "变量名'" +
-          constant_name +
-          "'长度过长，最大长度为20字符，建议使用: " +
-          recommend_info.recommended_name,
-      };
-    }
-
-    // 检查长度
-    var len_err = this._checkNameLength(
-      constant_name,
-      rule.min,
-      rule.max,
-      "variable-name",
-    );
-    if (len_err) {
-      return {
-        node: node,
-        message: len_err,
-      };
-    }
-
-    // 检查单词长度
-    var word_err = this._checkWordLength(
-      constant_name,
-      rule.single_word_len,
-      "constant-name",
-    );
-    if (word_err) {
-      return {
-        node: node,
-        message: word_err,
-      };
-    }
-
-    // 检查禁止词汇
-    var forbid_err = this._checkForbiddenWords(constant_name, "constant-name");
-    if (forbid_err) {
-      return {
-        node: node,
-        message: forbid_err,
-      };
-    }
-
-    return null;
-  } catch (error) {
-    console.error("检测解构赋值常量名时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性值命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyValueStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词
-    var forbid_err = this._checkForbiddenWords(prop_name, rule_type);
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查属性值类型，智能选择命名规范
-    var is_constant_value = this._isConstantValue(val_node);
-    var is_private_property = prop_name.startsWith("_");
-
-    // 属性值应该允许满足常量或变量命名规则之一即可
-    // 构建允许的命名风格列表
-    var allowed_styles = [];
-
-    // 常量值：允许常量命名规范
-    if (is_constant_value) {
-      allowed_styles.push("UPPER_SNAKE_CASE");
-    }
-
-    // 私有属性：允许私有变量命名规范
-    if (is_private_property) {
-      allowed_styles.push("_snake_case");
-    }
-
-    // 普通属性值：允许变量命名规范
-    allowed_styles.push("snake_case");
-
-    // 检查命名风格 - 只要满足其中一种风格即可
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性值名'" + prop_name + "'不符合" + style_names + "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性值命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性方法命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyMethodStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词 - 使用 method-name 规则类型
-    var forbid_err = this._checkForbiddenWords(prop_name, "method-name");
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查是否为私有属性方法
-    var is_private_method = prop_name.startsWith("_");
-
-    // 属性方法应该允许满足公开方法或私有方法命名规则之一即可
-    // 构建允许的命名风格列表
-    var allowed_styles = [];
-
-    // 私有属性方法：允许私有方法命名规范
-    if (is_private_method) {
-      allowed_styles.push("_camelCase");
-    }
-
-    // 公开属性方法：允许公开方法命名规范
-    allowed_styles.push("camelCase");
-
-    // 检查命名风格 - 只要满足其中一种风格即可
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性方法名'" + prop_name + "'不符合" + style_names + "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性方法命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性实例类命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyInstanceClassStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词
-    var forbid_err = this._checkForbiddenWords(prop_name, "method-name");
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查是否为私有属性实例类
-    var is_private_instance = prop_name.startsWith("_");
-
-    // 属性类实例应该允许满足公开或私有命名规则之一即可
-    // 构建允许的命名风格列表
-    var allowed_styles = [];
-
-    // 私有属性实例类：允许私有实例类命名规范
-    if (is_private_instance) {
-      allowed_styles.push("_camelCase");
-    }
-
-    // 公开属性实例类：允许公开实例类命名规范
-    allowed_styles.push("camelCase");
-
-    // 检查命名风格 - 只要满足其中一种风格即可
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性实例类名'" +
-      prop_name +
-      "'不符合" +
-      style_names +
-      "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性实例类命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查属性类命名风格
- * @param {string} prop_name 属性名
- * @param {object} val_node 属性值节点
- * @param {string} rule_type 规则类型
- * @returns {string|null} 错误信息或null
- */
-Detector.prototype._checkPropertyClassStyle = function (
-  prop_name,
-  val_node,
-  rule_type,
-) {
-  try {
-    // 首先检查禁止拼接词
-    var forbid_err = this._checkForbiddenWords(prop_name, "class-name");
-    if (forbid_err) {
-      return forbid_err;
-    }
-
-    // 检查是否为私有属性类
-    var is_private_class = prop_name.startsWith("_");
-
-    // 根据属性类类型选择合适的命名规范
-    var allowed_styles = [];
-
-    if (is_private_class) {
-      // 私有属性类：使用私有类命名规范
-      allowed_styles = ["_PascalCase"];
-    } else {
-      // 公开属性类：使用类命名规范
-      allowed_styles = ["PascalCase"];
-    }
-
-    // 检查命名风格
-    var style_err = null;
-    for (var i = 0; i < allowed_styles.length; i++) {
-      var style_check = this._validate_naming_style(
-        prop_name,
-        [allowed_styles[i]],
-        rule_type,
-      );
-      if (!style_check) {
-        // 当前风格符合要求，无需报错
-        return null;
-      }
-    }
-
-    // 所有风格都不符合，生成错误信息
-    var style_names = allowed_styles.join("、");
-
-    return (
-      "属性类名'" + prop_name + "'不符合" + style_names + "命名风格中的任何一种"
-    );
-  } catch (error) {
-    console.error("检查属性类命名风格时出错:", error);
-    return null;
-  }
-};
-
-/**
- * 检查是否为常量值
- * @param {object} val_node 属性值节点
- * @returns {boolean} 是否为常量值
- */
-Detector.prototype._isConstantValue = function (val_node) {
-  try {
-    if (!val_node) {
-      return false;
-    }
-
-    // 常量值类型：字面量、基础值、不可变值
-    var is_constant = false;
-
-    switch (val_node.type) {
-      case "Literal": // 字面量：数字、字符串、布尔值
-        is_constant = true;
-        break;
-      case "UnaryExpression": // 一元表达式（如 -1, +100）
-        if (val_node.operator === "-" || val_node.operator === "+") {
-          is_constant = true;
-        }
-        break;
-      case "ArrayExpression": // 数组字面量（空数组或包含常量值的数组）
-        if (!val_node.elements || val_node.elements.length === 0) {
-          is_constant = true;
-        } else {
-          // 检查数组元素是否都是常量值
-          is_constant = val_node.elements.every(function (element) {
-            return this._isConstantValue(element);
-          }, this);
-        }
-        break;
-      case "ObjectExpression": // 对象字面量（空对象或包含常量值的对象）
-        if (!val_node.properties || val_node.properties.length === 0) {
-          is_constant = true;
-        } else {
-          // 检查对象属性值是否都是常量值
-          is_constant = val_node.properties.every(function (property) {
-            return (
-              property &&
-              property.value &&
-              this._isConstantValue(property.value)
-            );
-          }, this);
-        }
-        break;
-      case "TemplateLiteral": // 模板字面量（包含常量值的模板）
-        if (!val_node.expressions || val_node.expressions.length === 0) {
-          is_constant = true;
-        } else {
-          // 检查模板表达式是否都是常量值
-          is_constant = val_node.expressions.every(function (expression) {
-            return this._isConstantValue(expression);
-          }, this);
-        }
-        break;
-      default:
-        is_constant = false;
-    }
-
-    return is_constant;
-  } catch (error) {
-    console.error("检查是否为常量值时出错:", error);
-    return false;
-  }
-};
-
-/**
- * 检测参数声明与函数内部引用是否一致
- * @param {object} context ESLint上下文
- * @param {object} node 函数节点（FunctionDeclaration、FunctionExpression、ArrowFunctionExpression）
- */
-Detector.prototype._checkParamReferences = function (context, node) {
-  try {
-    // 获取函数参数列表
-    var params = node.params || [];
-    if (params.length === 0) {
-      return; // 没有参数，无需检查
-    }
-
-    // 提取参数名
-    var param_names = [];
-    for (var i = 0; i < params.length; i++) {
-      var param = params[i];
-      if (param.type === 'Identifier') {
-        param_names.push(param.name);
-      }
-      // 处理解构参数
-      else if (param.type === 'ObjectPattern' && param.properties) {
-        for (var p = 0; p < param.properties.length; p++) {
-          var property = param.properties[p];
-          if (property.key && property.key.type === 'Identifier') {
-            param_names.push(property.key.name);
-          }
-        }
-      }
-    }
-
-    if (param_names.length === 0) {
-      return; // 没有有效的参数名
-    }
-
-    // 分析函数体内的标识符引用
-    var body_identifiers = this._extractIdentifiers(node.body);
-    
-    // 检查每个参数是否被正确引用
-    for (var j = 0; j < param_names.length; j++) {
-      var param_name = param_names[j];
-      var is_referenced = false;
-      var reference_errors = [];
-
-      // 检查参数是否被引用
-      for (var k = 0; k < body_identifiers.length; k++) {
-        var identifier = body_identifiers[k];
-        
-        // 检查标识符名称与参数名的相似性
-        if (this._isSimilarIdentifier(identifier.name, param_name)) {
-          if (identifier.name === param_name) {
-            // 完全匹配，正确引用
-            is_referenced = true;
-            break;
-          } else {
-            // 相似但不完全匹配，可能是拼写错误
-            reference_errors.push({
-              node: identifier.node,
-              actual_name: identifier.name,
-              expected_name: param_name
-            });
-          }
-        }
-      }
-
-      // 如果没有正确引用但有相似引用，报告错误
-      if (!is_referenced && reference_errors.length > 0) {
-        for (var m = 0; m < reference_errors.length; m++) {
-          var error = reference_errors[m];
-          
-          // 检查参数名是否符合命名规范，如果不符合，使用符合规范的名称
-          var param_name_err = this._checkParamName(param_name, null);
-          var recommended_name = param_name;
-          
-          if (param_name_err) {
-            var fix_suggestion = this._getFixSuggestion(param_name, 'param-name', param_name_err.message);
-            if (fix_suggestion && fix_suggestion.fixed_name !== param_name) {
-              recommended_name = fix_suggestion.fixed_name;
-            }
-          }
-          
-          context.report({
-            node: error.node,
-            message: "参数引用不一致：声明为 '" + param_name + "'，但引用为 '" + error.actual_name + "'，建议使用: " + recommended_name,
-            fix: function(fixer) {
-              return fixer.replaceText(error.node, recommended_name);
-            }
-          });
-        }
-      }
-    }
-  } catch (error) {
-    console.error("检查参数引用一致性时出错:", error);
-  }
-};
-
-/**
- * 提取函数体内的所有标识符
- * @param {object} node AST节点
- * @returns {array} 标识符数组
- */
-Detector.prototype._extractIdentifiers = function (node) {
-  var identifiers = [];
-  
-  if (!node) {
-    return identifiers;
-  }
-
-  var visited_nodes = new Set(); // 防止循环引用
-  var max_depth = 100; // 最大递归深度
-
-  // 递归遍历AST节点，提取标识符
-  function traverse(current_node, depth) {
-    if (!current_node || depth > max_depth) return;
-    
-    // 防止循环引用
-    if (visited_nodes.has(current_node)) return;
-    visited_nodes.add(current_node);
-
-    // 如果是标识符节点，添加到结果中
-    if (current_node.type === 'Identifier') {
-      identifiers.push({
-        name: current_node.name,
-        node: current_node
-      });
-      return;
-    }
-
-    // 遍历子节点
-    var child_nodes = [];
-    
-    switch (current_node.type) {
-      case 'FunctionExpression':
-      case 'FunctionDeclaration':
-      case 'ArrowFunctionExpression':
-        // 跳过函数定义，避免递归到参数
-        if (current_node.body) {
-          traverse(current_node.body, depth + 1);
-        }
-        break;
-      
-      case 'BlockStatement':
-        child_nodes = current_node.body || [];
-        break;
-      
-      case 'VariableDeclaration':
-        child_nodes = current_node.declarations || [];
-        break;
-      
-      case 'VariableDeclarator':
-        if (current_node.id) traverse(current_node.id, depth + 1);
-        if (current_node.init) traverse(current_node.init, depth + 1);
-        break;
-      
-      case 'ExpressionStatement':
-        if (current_node.expression) traverse(current_node.expression, depth + 1);
-        break;
-      
-      case 'CallExpression':
-        if (current_node.callee) traverse(current_node.callee, depth + 1);
-        child_nodes = current_node.arguments || [];
-        break;
-      
-      case 'MemberExpression':
-        if (current_node.object) traverse(current_node.object, depth + 1);
-        if (current_node.property) traverse(current_node.property, depth + 1);
-        break;
-      
-      case 'ReturnStatement':
-        if (current_node.argument) traverse(current_node.argument, depth + 1);
-        break;
-      
-      case 'BinaryExpression':
-      case 'LogicalExpression':
-        if (current_node.left) traverse(current_node.left, depth + 1);
-        if (current_node.right) traverse(current_node.right, depth + 1);
-        break;
-      
-      case 'UnaryExpression':
-        if (current_node.argument) traverse(current_node.argument, depth + 1);
-        break;
-      
-      case 'ConditionalExpression':
-        if (current_node.test) traverse(current_node.test, depth + 1);
-        if (current_node.consequent) traverse(current_node.consequent, depth + 1);
-        if (current_node.alternate) traverse(current_node.alternate, depth + 1);
-        break;
-      
-      case 'ArrayExpression':
-        child_nodes = current_node.elements || [];
-        break;
-      
-      case 'ObjectExpression':
-        child_nodes = current_node.properties || [];
-        break;
-      
-      case 'Property':
-        if (current_node.key) traverse(current_node.key, depth + 1);
-        if (current_node.value) traverse(current_node.value, depth + 1);
-        break;
-      
-      case 'Literal':
-        // 字面量，跳过
-        break;
-      
-      default:
-        // 对于其他节点类型，只遍历已知的AST属性，避免无限递归
-        var ast_props = ['body', 'declarations', 'expression', 'callee', 'arguments', 
-                        'object', 'property', 'argument', 'left', 'right', 'test', 
-                        'consequent', 'alternate', 'elements', 'properties', 'key', 'value'];
-        
-        for (var i = 0; i < ast_props.length; i++) {
-          var prop = ast_props[i];
-          var value = current_node[prop];
-          
-          if (Array.isArray(value)) {
-            for (var j = 0; j < value.length; j++) {
-              if (value[j] && typeof value[j] === 'object' && value[j].type) {
-                traverse(value[j], depth + 1);
-              }
-            }
-          } else if (value && typeof value === 'object' && value.type) {
-            traverse(value, depth + 1);
-          }
-        }
-        break;
-    }
-
-    // 遍历子节点数组
-    for (var k = 0; k < child_nodes.length; k++) {
-      if (child_nodes[k] && typeof child_nodes[k] === 'object' && child_nodes[k].type) {
-        traverse(child_nodes[k], depth + 1);
-      }
-    }
-  }
-
-  traverse(node, 0);
-  return identifiers;
-};
-
-/**
- * 检查两个标识符是否相似（用于检测拼写错误）
- * @param {string} actual_name 实际使用的名称
- * @param {string} expected_name 期望的名称
- * @returns {boolean} 是否相似
- */
-Detector.prototype._isSimilarIdentifier = function (actual_name, expected_name) {
-  if (actual_name === expected_name) {
-    return true;
-  }
-
-  // 检查大小写不一致的情况
-  if (actual_name.toLowerCase() === expected_name.toLowerCase()) {
     return true;
   }
+}
 
-  // 检查常见的拼写错误模式
-  var common_patterns = [
-    // 下划线相关错误
-    { pattern: /_/g, replacement: '' }, // 忘记下划线
-    { pattern: /([a-z])([A-Z])/g, replacement: '$1_$2' }, // 驼峰转蛇形
-    { pattern: /_([a-z])/g, replacement: function(match, p1) { return p1.toUpperCase(); } } // 蛇形转驼峰
-  ];
-
-  for (var i = 0; i < common_patterns.length; i++) {
-    var pattern = common_patterns[i];
-    var transformed_actual = actual_name.replace(pattern.pattern, pattern.replacement);
-    var transformed_expected = expected_name.replace(pattern.pattern, pattern.replacement);
-    
-    if (transformed_actual === transformed_expected || 
-        transformed_actual.toLowerCase() === transformed_expected.toLowerCase()) {
-      return true;
-    }
-  }
-
-  // 检查编辑距离（简单的相似度检查）
-  var distance = this._levenshteinDistance(actual_name.toLowerCase(), expected_name.toLowerCase());
-  var max_length = Math.max(actual_name.length, expected_name.length);
-  var similarity = 1 - (distance / max_length);
-  
-  return similarity > 0.7; // 相似度超过70%认为相似
-};
-
-/**
- * 计算两个字符串的编辑距离（Levenshtein距离）
- * @param {string} a 字符串A
- * @param {string} b 字符串B
- * @returns {number} 编辑距离
- */
-Detector.prototype._levenshteinDistance = function (a, b) {
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-
-  var matrix = [];
-
-  // 初始化矩阵
-  for (var i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-
-  for (var j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-
-  // 计算编辑距离
-  for (i = 1; i <= b.length; i++) {
-    for (j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1, // 替换
-          matrix[i][j - 1] + 1,     // 插入
-          matrix[i - 1][j] + 1      // 删除
-        );
-      }
-    }
-  }
-
-  return matrix[b.length][a.length];
-};
-
-/**
- * 检查是否为 module.exports 中的属性
- * @param {object} node 属性节点
- * @param {object} parent_node 父节点信息
- * @returns {boolean} 是否为 module.exports 中的属性
- */
-Detector.prototype._isModuleExportsProperty = function (node, parent_node) {
-  try {
-    // 处理新的父节点信息结构（包含node和parent属性）
-    var actual_parent_node = parent_node;
-    if (parent_node && typeof parent_node === "object" && parent_node.node) {
-      actual_parent_node = parent_node.node;
-    }
-
-    if (!node || !actual_parent_node) {
-      return false;
-    }
-
-    // 检查父节点是否为 ObjectExpression（对象字面量）
-    if (actual_parent_node.type === "ObjectExpression") {
-      // 检查父节点的父节点是否为 AssignmentExpression
-      var actual_parent_parent =
-        parent_node && typeof parent_node === "object" && parent_node.parent
-          ? parent_node.parent
-          : null;
-
-      if (
-        actual_parent_parent &&
-        actual_parent_parent.type === "AssignmentExpression"
-      ) {
-        // 检查赋值表达式的左侧是否为 module.exports
-        var left = actual_parent_parent.left;
-        if (
-          left &&
-          left.type === "MemberExpression" &&
-          left.object &&
-          left.object.type === "Identifier" &&
-          left.object.name === "module" &&
-          left.property &&
-          left.property.type === "Identifier" &&
-          left.property.name === "exports"
-        ) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  } catch (error) {
-    console.error("检查是否为 module.exports 中的属性时出错:", error);
-    return false;
-  }
-};
-
-module.exports = { Detector };
+module.exports = { Detector };