mm_eslint 1.4.3 → 1.4.4

package/index.js

@@ -1,1297 +1,1045 @@
-/**
- * ESLint命名规范检测插件
- * 版本: 1.1.0 - 支持跳过null值和未赋值属性检测
- */
-
-const { Config } = require('./config');
-const { Detector } = require('./detector');
-
-/**
- * 创建ESLint规则配置
- * @returns {object} ESLint规则配置对象
- */
-function createNamingRules() {
-  var config = new Config({});
-  var detector = new Detector(config);
-
-  /**
-   * 检查节点是否为参数名或参数引用
-   * @param {object} node AST节点
-   * @returns {boolean} 是否为参数名或参数引用
-   */
-  function _isParameterName(node) {
-    if (!node || !node.parent) {
-      return false;
-    }
-    
-    // 检查是否为函数参数声明
-    var parent = node.parent;
-    if (parent.type === 'FunctionDeclaration' || 
-        parent.type === 'FunctionExpression' || 
-        parent.type === 'ArrowFunctionExpression') {
-      if (parent.params && Array.isArray(parent.params)) {
-        for (var i = 0; i < parent.params.length; i++) {
-          if (parent.params[i] === node) {
-            return true;
-          }
-        }
-      }
-    }
-    
-    // 检查是否为变量声明中的参数
-    if (parent.type === 'VariableDeclarator' && parent.id === node) {
-      var grand_parent = parent.parent;
-      if (grand_parent && grand_parent.type === 'VariableDeclaration') {
-        // 检查是否为函数参数
-        var great_grand_parent = grand_parent.parent;
-        if (great_grand_parent && 
-            (great_grand_parent.type === 'FunctionDeclaration' || 
-             great_grand_parent.type === 'FunctionExpression' || 
-             great_grand_parent.type === 'ArrowFunctionExpression')) {
-          return true;
-        }
-      }
-    }
-    
-    // 检查是否为参数引用（在函数调用中）
-    if (node.type === 'Identifier') {
-      // 检查是否在函数调用表达式中
-      if (parent.type === 'CallExpression' && parent.callee === node) {
-        // 检查是否在函数作用域内
-        var current_scope = parent;
-        while (current_scope) {
-          // 检查当前作用域是否为函数
-          if (current_scope.type === 'FunctionDeclaration' || 
-              current_scope.type === 'FunctionExpression' || 
-              current_scope.type === 'ArrowFunctionExpression') {
-            // 检查函数参数中是否有同名参数
-            if (current_scope.params && Array.isArray(current_scope.params)) {
-              for (var i = 0; i < current_scope.params.length; i++) {
-                var param = current_scope.params[i];
-                if (param.type === 'Identifier' && param.name === node.name) {
-                  return true;
-                }
-              }
-            }
-            break;
-          }
-          current_scope = current_scope.parent;
-        }
-      }
-    }
-    
-    return false;
-  }
-
-  return {
-    'class-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测类名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          ClassDeclaration: function (node) {
-            var class_name = node.id.name;
-            var err = detector._checkClassName(class_name, node);
-            if (err) {
-              // 获取修复建议
-              var fix_suggestion = detector._getFixSuggestion(class_name, 'class-name', err.message);
-              
-              var report_obj = {
-                node: err.node,
-                message: err.message,
-              };
-              
-              // 如果有修复建议，添加修复功能
-              if (fix_suggestion) {
-                report_obj.fix = function(fixer) {
-                  return fixer.replaceText(node.id, fix_suggestion.fixed_name);
-                };
-                report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-              }
-              
-              context.report(report_obj);
-            }
-          },
-        };
-      },
-    },
-
-    'function-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测函数名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          FunctionDeclaration: function (node) {
-            if (node.id) {
-              var function_name = node.id.name;
-              var err = detector._checkFunctionName(function_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(function_name, 'function-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.id, fix_suggestion.fixed_name);
-                  };
-                  // 只有当错误消息中不包含建议时才添加建议
-                  if (!err.message.includes('建议使用:')) {
-                    report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-          FunctionExpression: function (node) {
-            if (node.id) {
-              var function_name = node.id.name;
-              var err = detector._checkFunctionName(function_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(function_name, 'function-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.id, fix_suggestion.fixed_name);
-                  };
-                  // 只有当错误消息中不包含建议时才添加建议
-                  if (!err.message.includes('建议使用:')) {
-                    report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'function-call-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测函数调用名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        var self = this;
-        
-        return {
-          CallExpression: function (node) {
-            if (node.callee && node.callee.type === 'Identifier') {
-              var function_name = node.callee.name;
-              
-              // 检查是否为参数名，如果是参数名则跳过检测（避免与参数名规则冲突）
-              if (_isParameterName(node.callee)) {
-                return;
-              }
-              
-              // 只检测函数调用名中的明显错误，如大写开头或蛇形命名
-              var err = detector._checkFunctionName(function_name, node);
-              if (err && (err.message.includes('不符合camelCase命名风格') || err.message.includes('不符合命名规范'))) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(function_name, 'function-name', err.message);
-                
-                // 根据错误类型生成具体的错误消息
-                var error_detail = '';
-                if (err.message.includes('不符合camelCase命名风格')) {
-                  error_detail = '不符合camelCase命名风格';
-                } else if (err.message.includes('长度过长')) {
-                  error_detail = '长度过长，最大长度为20字符';
-                } else if (err.message.includes('长度过短')) {
-                  error_detail = '长度过短，最小长度为1字符';
-                } else if (err.message.includes('单词过长')) {
-                  error_detail = '包含的单词过长，最大长度为8字符';
-                } else {
-                  error_detail = '不符合命名规范';
-                }
-                
-                var report_obj = {
-                  node: node.callee,
-                  message: '函数调用名\'' + function_name + '\'' + error_detail + '，建议使用: ' + (fix_suggestion ? fix_suggestion.fixed_name : '符合规范的名称'),
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.callee, fix_suggestion.fixed_name);
-                  };
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'method-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测方法名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          MethodDefinition: function (node) {
-            if (node.key && node.key.name) {
-              var method_name = node.key.name;
-              var err = detector._checkMethodName(method_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(method_name, 'method-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  // 只有当错误消息中不包含建议时才添加建议
-                  if (!err.message.includes('建议使用:')) {
-                    report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-          
-          // 处理原型方法定义：ClassName.prototype.method_name = function() {}
-          AssignmentExpression: function (node) {
-            if (node.left && 
-                node.left.type === 'MemberExpression' &&
-                node.left.object && 
-                node.left.object.type === 'MemberExpression' &&
-                node.left.object.property && 
-                node.left.object.property.name === 'prototype' &&
-                node.left.property && 
-                node.left.property.type === 'Identifier' &&
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
-              
-              var method_name = node.left.property.name;
-              var err = detector._checkMethodName(method_name, node);
-              if (err) {
-                // 检查是否为建议类型（不是错误）
-                if (err.type === 'suggestion') {
-                  // 建议性提示，直接使用返回的错误信息
-                  var report_obj = {
-                    node: node.left.property,
-                    message: err.message,
-                  };
-                } else {
-                  // 错误性提示，直接使用检测器返回的错误信息（已经包含推荐建议）
-                  var report_obj = {
-                    node: node.left.property,
-                    message: err.message,
-                  };
-                  
-                  // 如果有修复建议，添加修复功能
-                  var fix_suggestion = detector._getFixSuggestion(method_name, 'method-name', err.message);
-                  if (fix_suggestion) {
-                    report_obj.fix = function(fixer) {
-                      return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                    };
-                  }
-                }
-                
-                context.report(report_obj);
-              }
-            }
-            
-            // 处理类实例方法定义：this.method_name = function() {}
-            if (node.left && 
-                node.left.type === 'MemberExpression' &&
-                node.left.object && 
-                node.left.object.type === 'ThisExpression' &&
-                node.left.property && 
-                node.left.property.type === 'Identifier' &&
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
-              
-              var method_name = node.left.property.name;
-              var err = detector._checkMethodName(method_name, node);
-              if (err) {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(method_name, 'method-name', err.message);
-                
-                // 检查错误信息是否包含推荐词
-                var recommendation_match = err.message.match(/建议使用'([^']+)'/);
-                var recommended_name = recommendation_match ? recommendation_match[1] : null;
-                
-                var suggestion_text = '符合规范的名称';
-                if (fix_suggestion) {
-                  suggestion_text = fix_suggestion.fixed_name;
-                } else if (recommended_name) {
-                  suggestion_text = recommended_name;
-                }
-                
-                var report_obj = {
-                  node: node.left.property,
-                  message: '方法名\'' + method_name + '\'不符合命名规范，建议使用: ' + suggestion_text,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'variable-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测变量名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          VariableDeclaration: function (node) {
-            // 排除const声明，只检测let和var声明的变量
-            if (node.kind !== 'const') {
-              node.declarations.forEach(function(decl) {
-                // 处理简单变量声明
-                if (decl.id && decl.id.type === 'Identifier') {
-                  var variable_name = decl.id.name;
-                  var err = detector._checkVariableName(variable_name, decl);
-                  if (err) {
-                    // 获取修复建议
-                    var fix_suggestion = detector._getFixSuggestion(variable_name, 'variable-name', err.message);
-                    
-                    var report_obj = {
-                      node: decl.id,
-                      message: err.message,
-                    };
-                    
-                    // 如果有修复建议，添加修复功能
-                    if (fix_suggestion) {
-                      report_obj.fix = function(fixer) {
-                        return fixer.replaceText(decl.id, fix_suggestion.fixed_name);
-                      };
-                      report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                    }
-                    
-                    context.report(report_obj);
-                  }
-                }
-                // 处理解构赋值 - ObjectPattern
-                else if (decl.id && decl.id.type === 'ObjectPattern') {
-                  decl.id.properties.forEach(function(property) {
-                    if (property.key && property.key.type === 'Identifier') {
-                      var variable_name = property.key.name;
-                      var err = detector._checkVariableName(variable_name, decl);
-                      if (err) {
-                        // 获取修复建议
-                        var fix_suggestion = detector._getFixSuggestion(variable_name, 'variable-name', err.message);
-                        
-                        var report_obj = {
-                          node: property.key,
-                          message: err.message,
-                        };
-                        
-                        // 如果有修复建议，添加修复功能
-                        if (fix_suggestion) {
-                          report_obj.fix = function(fixer) {
-                            return fixer.replaceText(property.key, fix_suggestion.fixed_name);
-                          };
-                          report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                        }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-                // 处理解构赋值 - ArrayPattern
-                else if (decl.id && decl.id.type === 'ArrayPattern') {
-                  decl.id.elements.forEach(function(element, index) {
-                    if (element && element.type === 'Identifier') {
-                      var variable_name = element.name;
-                      var err = detector._checkVariableName(variable_name, decl);
-                      if (err) {
-                        // 获取修复建议
-                        var fix_suggestion = detector._getFixSuggestion(variable_name, 'variable-name', err.message);
-                        
-                        var report_obj = {
-                          node: element,
-                          message: err.message,
-                        };
-                        
-                        // 如果有修复建议，添加修复功能
-                        if (fix_suggestion) {
-                          report_obj.fix = function(fixer) {
-                            return fixer.replaceText(element, fix_suggestion.fixed_name);
-                          };
-                          report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                        }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-              });
-            }
-          },
-        };
-      },
-    },
-
-    'param-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测参数名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          FunctionDeclaration: function (node) {
-            _fixParamAndReferences(context, node, detector);
-          },
-          FunctionExpression: function (node) {
-            _fixParamAndReferences(context, node, detector);
-          },
-          ArrowFunctionExpression: function (node) {
-            _fixParamAndReferences(context, node, detector);
-          },
-        };
-      },
-    },
-
-    'constant-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '检测常量名是否符合命名规范',
-          category: 'Stylistic Issues',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          VariableDeclaration: function (node) {
-            if (node.kind === 'const') {
-              node.declarations.forEach(function(decl) {
-                // 处理简单变量声明
-                if (decl.id && decl.id.type === 'Identifier') {
-                  var constant_name = decl.id.name;
-                  var err = detector._checkConstantName(constant_name, decl, decl.init);
-                  if (err) {
-                    var report_obj = {
-                      node: decl.id,
-                      message: err.message,
-                    };
-                    
-                    // 如果错误是"应该使用let而不是const"，提供const→let修复功能
-                    if (err.message.includes('应该使用let而不是const')) {
-                      report_obj.fix = function(fixer) {
-                        // 替换const为let
-                        var const_range = [node.range[0], node.range[0] + 5]; // const的位置
-                        return fixer.replaceTextRange(const_range, 'let');
-                      };
-                      report_obj.message += '，建议将const改为let';
-                    }
-                    // 否则提供命名风格修复建议
-                    else {
-                      // 使用检测器返回的规则类型（优先）
-                      var rule_type = err.rule_type || 'constant-name';
-                      
-                      // 如果没有返回规则类型，根据错误信息确定正确的规则类型
-                      if (!err.rule_type) {
-                        if (err.message.includes('函数名')) {
-                          rule_type = 'function-name';
-                        } else if (err.message.includes('变量名')) {
-                          rule_type = 'variable-name';
-                        } else if (err.message.includes('类名')) {
-                          rule_type = 'class-name';
-                        } else if (err.message.includes('属性名')) {
-                          rule_type = 'property-name';
-                        } else if (err.message.includes('方法名')) {
-                          rule_type = 'method-name';
-                        }
-                      }
-                      
-                      // 获取修复建议
-                      var fix_suggestion = detector._getFixSuggestion(constant_name, rule_type, err.message);
-                      
-                      // 如果有修复建议，添加修复功能
-                      if (fix_suggestion) {
-                        report_obj.fix = function(fixer) {
-                          return fixer.replaceText(decl.id, fix_suggestion.fixed_name);
-                        };
-                        
-                        // 只有当错误消息中不包含建议时才添加建议
-                        if (!err.message.includes('建议使用:')) {
-                          report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                        }
-                      }
-                      
-                      // 设置正确的规则类型用于ESLint报告
-                      report_obj.ruleId = 'mm_eslint/' + rule_type;
-                    }
-                    
-                    context.report(report_obj);
-                  }
-                }
-                // 处理解构赋值 - ObjectPattern
-                else if (decl.id && decl.id.type === 'ObjectPattern') {
-                  decl.id.properties.forEach(function(property) {
-                    if (property.key && property.key.type === 'Identifier') {
-                      var constant_name = property.key.name;
-                      // 对于解构赋值，使用专门的检测方法
-                      var err = detector._checkConstantNameForDestructuring(constant_name, property.key);
-                      if (err) {
-                        var report_obj = {
-                          node: property.key,
-                          message: err.message,
-                        };
-                        
-                        // 如果错误是"应该使用let而不是const"，提供const→let修复功能
-                        if (err.message.includes('应该使用let而不是const')) {
-                          report_obj.fix = function(fixer) {
-                            // 替换const为let
-                            var const_range = [node.range[0], node.range[0] + 5]; // const的位置
-                            return fixer.replaceTextRange(const_range, 'let');
-                          };
-                          report_obj.message += '，建议将const改为let';
-                        }
-                        // 否则提供命名风格修复建议
-                        else {
-                          // 根据错误信息确定正确的规则类型
-                          var rule_type = 'constant-name';
-                          if (err.message.includes('函数名')) {
-                            rule_type = 'function-name';
-                          } else if (err.message.includes('变量名')) {
-                            rule_type = 'variable-name';
-                          } else if (err.message.includes('类名')) {
-                            rule_type = 'class-name';
-                          } else if (err.message.includes('属性名')) {
-                            rule_type = 'property-name';
-                          } else if (err.message.includes('方法名')) {
-                            rule_type = 'method-name';
-                          }
-                          
-                          // 获取修复建议
-                          var fix_suggestion = detector._getFixSuggestion(constant_name, rule_type, err.message);
-                          
-                          // 如果有修复建议，添加修复功能
-                          if (fix_suggestion) {
-                            report_obj.fix = function(fixer) {
-                              return fixer.replaceText(property.key, fix_suggestion.fixed_name);
-                            };
-                            report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                          }
-                        }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-                // 处理解构赋值 - ArrayPattern
-                else if (decl.id && decl.id.type === 'ArrayPattern') {
-                  decl.id.elements.forEach(function(element, index) {
-                    if (element && element.type === 'Identifier') {
-                      var constant_name = element.name;
-                      // 对于解构赋值，使用专门的检测方法
-                      var err = detector._checkConstantNameForDestructuring(constant_name, element);
-                      if (err) {
-                        // 根据错误信息确定正确的规则类型
-                      var rule_type = 'variable-name';
-                      if (err.message.includes('函数名')) {
-                        rule_type = 'function-name';
-                      } else if (err.message.includes('变量名')) {
-                        rule_type = 'variable-name';
-                      } else if (err.message.includes('类名')) {
-                        rule_type = 'class-name';
-                      } else if (err.message.includes('属性名')) {
-                        rule_type = 'property-name';
-                      } else if (err.message.includes('方法名')) {
-                        rule_type = 'method-name';
-                      }
-                      
-                      // 获取修复建议
-                      var fix_suggestion = detector._getFixSuggestion(constant_name, rule_type, err.message);
-                      
-                      var report_obj = {
-                        node: element,
-                        message: err.message,
-                      };
-                      
-                      // 如果有修复建议，添加修复功能
-                      if (fix_suggestion) {
-                        report_obj.fix = function(fixer) {
-                          return fixer.replaceText(element, fix_suggestion.fixed_name);
-                        };
-                        report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                      }
-                        
-                        context.report(report_obj);
-                      }
-                    }
-                  });
-                }
-              });
-            }
-          },
-        };
-      },
-    },
-
-    'property-value-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性值名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
-          Property: function (node) {
-          if (node.key && node.key.name) {
-            var prop_name = node.key.name;
-            
-            // 直接跳过null值和未赋值属性的检测
-            // 注意：null值的类型是Literal，但value为null
-            var is_null_value = node.value && node.value.type === 'Literal' && node.value.value === null;
-            var is_undefined_value = !node.value;
-            
-            if (is_null_value || is_undefined_value) {
-              // 对于null值和未赋值属性，直接跳过检测，不报错
-              return;
-            }
-            
-            // 传递祖父节点信息，用于第三方库排除检测
-            var parent_info = {
-              node: node.parent,
-              parent: node.parent ? node.parent.parent : null
-            };
-            
-            var err = detector._checkPropertyName(
-              prop_name,
-              node,
-              node.value,
-              parent_info,
-            );
-            
-            // 只处理属性值名相关的错误
-            if (err && err.rule_type === 'property-value-name') {
-              // 获取修复建议
-              var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-value-name', err.message);
-              
-              var report_obj = {
-                node: err.node,
-                message: err.message,
-              };
-              
-              // 如果有修复建议，添加修复功能
-              if (fix_suggestion) {
-                report_obj.fix = function(fixer) {
-                  return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                };
-                report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-              }
-              
-              context.report(report_obj);
-            }
-          }
-        },
-          // 检测类实例属性 (this.xxx)
-          AssignmentExpression: function (node) {
-            // 检查是否是 this.xxx = value 形式的赋值
-            if (node.left && node.left.type === 'MemberExpression' &&
-                node.left.object && node.left.object.type === 'ThisExpression' &&
-                node.left.property && node.left.property.type === 'Identifier') {
-              
-              // 排除类实例方法：this.method_name = function() {}
-              var is_instance_method = 
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression');
-              
-              if (is_instance_method) {
-                // 类实例方法由 method-name 规则处理，跳过
-                return;
-              }
-              
-              var prop_name = node.left.property.name;
-              
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node.left.property,
-                node.right,
-                parent_info,
-              );
-              
-              // 处理所有属性相关的错误类型，但排除 property-instance-class-name（由专门规则处理）
-              if (err && err.rule_type && err.rule_type.startsWith('property-') && 
-                  err.rule_type !== 'property-instance-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, err.rule_type, err.message);
-                
-                var report_obj = {
-                  node: node.left.property,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-          // 检测普通属性赋值，排除原型方法
-          AssignmentExpression: function (node) {
-            if (
-              node.left &&
-              node.left.type === 'MemberExpression' &&
-              node.left.property &&
-              node.left.property.name
-            ) {
-              // 排除原型方法：ClassName.prototype.method_name = function() {}
-              var is_prototype_method = 
-                node.left.object && 
-                node.left.object.type === 'MemberExpression' &&
-                node.left.object.property && 
-                node.left.object.property.name === 'prototype' &&
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression');
-              
-              if (is_prototype_method) {
-                // 原型方法由 method-name 规则处理，跳过
-                return;
-              }
-              
-              var prop_name = node.left.property.name;
-              
-              // 直接跳过null值和未赋值属性的检测
-              // 注意：null值的类型是Literal，但value为null
-              var is_null_value = node.right && node.right.type === 'Literal' && node.right.value === null;
-              var is_undefined_value = !node.right;
-              
-              if (is_null_value || is_undefined_value) {
-                // 对于null值和未赋值属性，直接跳过检测，不报错
-                return;
-              }
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node,
-                node.right,
-                node.parent,
-              );
-              
-              // 只处理属性值名相关的错误
-              if (err && err.rule_type === 'property-value-name') {
-                  // 获取修复建议
-                  var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-value-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'property-method-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性方法名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
-          Property: function (node) {
-            if (node.key && node.key.name) {
-              var prop_name = node.key.name;
-              
-              // 传递祖父节点信息，用于第三方库排除检测
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node,
-                node.value,
-                parent_info,
-              );
-              
-              // 只处理属性方法名相关的错误
-              if (err && err.rule_type === 'property-method-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-method-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'property-class-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性类名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
-          Property: function (node) {
-            if (node.key && node.key.name) {
-              var prop_name = node.key.name;
-              
-              // 传递祖父节点信息，用于第三方库排除检测
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              var err = detector._checkPropertyName(
-                prop_name,
-                node,
-                node.value,
-                parent_info,
-              );
-              
-              // 只处理属性类名相关的错误
-              if (err && err.rule_type === 'property-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-class-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'property-instance-class-name': {
-      meta: {
-        type: 'suggestion',
-        docs: {
-          description: '属性实例类名命名规范检测',
-          category: 'Stylistic Issues',
-          recommended: true
-        },
-        fixable: 'code',
-        schema: []
-      },
-      create: function (context) {
-        return {
-          // 检测对象字面量中的属性实例类名
-          Property: function (node) {
-            if (node.key && node.key.name) {
-              var prop_name = node.key.name;
-              
-              // 传递祖父节点信息，用于第三方库排除检测
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              // 检测属性命名
-              var err = detector._checkPropertyName(
-                prop_name,
-                node.key,
-                node.value,
-                parent_info,
-              );
-              
-              // 只处理属性实例类名相关的错误
-              if (err && err.rule_type === 'property-instance-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-instance-class-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.key, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-          
-          // 检测类实例属性中的属性实例类名 (this.xxx)
-          AssignmentExpression: function (node) {
-            // 检查是否是 this.xxx = value 形式的赋值
-            if (node.left && node.left.type === 'MemberExpression' &&
-                node.left.object && node.left.object.type === 'ThisExpression' &&
-                node.left.property && node.left.property.type === 'Identifier') {
-              
-              // 排除类实例方法：this.method_name = function() {}
-              var is_instance_method = 
-                node.right && 
-                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression');
-              
-              if (is_instance_method) {
-                // 类实例方法由 method-name 规则处理，跳过
-                return;
-              }
-              
-              var prop_name = node.left.property.name;
-              
-              var parent_info = {
-                node: node.parent,
-                parent: node.parent ? node.parent.parent : null
-              };
-              
-              // 检测属性命名
-              var err = detector._checkPropertyName(
-                prop_name,
-                node.left.property,
-                node.right,
-                parent_info,
-              );
-              
-              // 只处理属性实例类名相关的错误
-              if (err && err.rule_type === 'property-instance-class-name') {
-                // 获取修复建议
-                var fix_suggestion = detector._getFixSuggestion(prop_name, 'property-instance-class-name', err.message);
-                
-                var report_obj = {
-                  node: err.node,
-                  message: err.message,
-                };
-                
-                // 如果有修复建议，添加修复功能
-                if (fix_suggestion) {
-                  report_obj.fix = function(fixer) {
-                    return fixer.replaceText(node.left.property, fix_suggestion.fixed_name);
-                  };
-                  report_obj.message += '，建议使用: ' + fix_suggestion.fixed_name;
-                }
-                
-                context.report(report_obj);
-              }
-            }
-          },
-        };
-      },
-    },
-
-    'param-reference-consistency': {
-      meta: {
-        type: 'problem',
-        docs: {
-          description: '检测参数声明与函数内部引用是否一致',
-          category: 'Possible Errors',
-          recommended: true,
-        },
-        fixable: 'code',
-        schema: [],
-      },
-      create: function (context) {
-        return {
-          FunctionDeclaration: function (node) {
-            detector._checkParamReferences(context, node);
-          },
-          FunctionExpression: function (node) {
-            detector._checkParamReferences(context, node);
-          },
-          ArrowFunctionExpression: function (node) {
-            detector._checkParamReferences(context, node);
-          },
-        };
-      },
-    },
-  };
-}
-
-/**
- * 修复参数声明和所有相关引用
- * @param {object} context ESLint上下文
- * @param {object} node 函数节点
- * @param {object} detector 检测器实例
- */
-function _fixParamAndReferences(context, node, detector) {
-  if (!node.params || !node.body) return;
-  
-  // 收集需要修复的参数映射
-  var param_fixes = [];
-  
-  node.params.forEach(function(param) {
-    if (param.name) {
-      var param_name = param.name;
-      var err = detector._checkParamName(param_name, param);
-      if (err) {
-        var fix_suggestion = detector._getFixSuggestion(param_name, 'param-name', err.message);
-        if (fix_suggestion && fix_suggestion.fixed_name !== param_name) {
-          param_fixes.push({
-            param_node: param,
-            old_name: param_name,
-            new_name: fix_suggestion.fixed_name,
-            message: err.message + '，建议使用: ' + fix_suggestion.fixed_name
-          });
-        }
-      }
-    }
-  });
-  
-  // 如果没有需要修复的参数，直接返回
-  if (param_fixes.length === 0) return;
-  
-  // 分步修复：先修复参数声明，然后单独检测引用不一致问题
-  param_fixes.forEach(function(fix_info) {
-    // 第一步：修复参数声明
-    context.report({
-      node: fix_info.param_node,
-      message: fix_info.message,
-      fix: function(fixer) {
-        return fixer.replaceText(fix_info.param_node, fix_info.new_name);
-      }
-    });
-    
-    // 第二步：检测并修复函数体内的引用不一致问题
-    _checkParamReferenceInconsistencies(context, node, fix_info);
-  });
-}
-
-/**
- * 检查并修复参数引用不一致问题
- * @param {object} context ESLint上下文
- * @param {object} node 函数节点
- * @param {object} fix_info 修复信息
- */
-function _checkParamReferenceInconsistencies(context, node, fix_info) {
-  var source_code = context.getSourceCode();
-  
-  // 使用深度优先搜索遍历AST
-  function findIdentifierReferences(astNode, oldName) {
-    var references = [];
-    var visited = new Set();
-    
-    function traverse(currentNode) {
-      // 防止循环引用导致的无限递归
-      if (!currentNode || visited.has(currentNode) || typeof currentNode !== 'object') {
-        return;
-      }
-      visited.add(currentNode);
-      
-      // 检查当前节点是否为标识符节点
-      if (currentNode.type === 'Identifier' && currentNode.name === oldName) {
-        // 排除参数声明节点本身
-        if (currentNode !== fix_info.param_node) {
-          references.push(currentNode);
-        }
-      }
-      
-      // 深度优先遍历所有子节点
-      var stack = [currentNode];
-      
-      while (stack.length > 0) {
-        var current = stack.pop();
-        
-        // 遍历当前节点的所有属性
-        Object.keys(current).forEach(function(key) {
-          // 跳过可能引起循环的属性
-          if (key === 'parent' || key === 'range' || key === 'loc' || key === 'comments') {
-            return;
-          }
-          
-          var child = current[key];
-          
-          if (child && typeof child === 'object') {
-            if (Array.isArray(child)) {
-              // 将数组元素逆序压入栈中，保持遍历顺序
-              for (var i = child.length - 1; i >= 0; i--) {
-                var item = child[i];
-                if (item && typeof item === 'object' && !visited.has(item)) {
-                  visited.add(item);
-                  
-                  // 检查是否为标识符节点
-                  if (item.type === 'Identifier' && item.name === oldName && item !== fix_info.param_node) {
-                    references.push(item);
-                  }
-                  
-                  stack.push(item);
-                }
-              }
-            } else if (!visited.has(child)) {
-              visited.add(child);
-              
-              // 检查是否为标识符节点
-              if (child.type === 'Identifier' && child.name === oldName && child !== fix_info.param_node) {
-                references.push(child);
-              }
-              
-              stack.push(child);
-            }
-          }
-        });
-      }
-    }
-    
-    traverse(astNode);
-    return references;
-  }
-  
-  // 查找函数体内的所有引用
-  var references = findIdentifierReferences(node.body, fix_info.old_name);
-  
-  // 如果找到引用，创建一个包含所有修复的单一修复函数
-  if (references.length > 0) {
-    context.report({
-      node: node,
-      message: '参数引用不一致：' + fix_info.old_name + ' 应该使用 ' + fix_info.new_name + ' (找到 ' + references.length + ' 个引用)',
-      fix: function(fixer) {
-        var fixes = [];
-        
-        // 为每个引用添加修复
-        references.forEach(function(refNode) {
-          fixes.push(fixer.replaceText(refNode, fix_info.new_name));
-        });
-        
-        // 返回所有修复的数组
-        return fixes;
-      }
-    });
-  }
-}
-
-module.exports = {
-  rules: createNamingRules(),
-};
+/**
+ * ESLint命名规范检测插件
+ * 版本: 1.2.0 - 模块化重构版，职责分离
+ */
+
+const { Detector } = require('./detector.js');
+
+/**
+ * 创建ESLint规则配置
+ * @returns {object} ESLint规则配置对象
+ */
+function createNamingRules() {
+  var detector = new Detector();
+  
+  /**
+   * 检测命名并返回错误信息
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @param {string} expected_type 期望的命名类型
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectNamingError(name, node, expected_type = null) {
+    // 使用detector检测命名类型，传入期望类型进行过滤
+    var info = detector.detect(name, node, expected_type);
+    if (!info) {
+      return null;
+    }
+
+    var fix_suggestion = info.fix_suggestion;
+    // 如果有修复建议，添加修复功能
+    if (fix_suggestion) {
+      info.fix = function (fixer) {
+        return fixer.replaceText(node, fix_suggestion);
+      };
+    }
+    // 返回错误信息
+    return info;
+  }
+
+  /**
+   * 检测类名命名规范
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectClassName(name, node) {
+    return _detectNamingError(name, node, 'class');
+  }
+
+  /**
+   * 检测类实例名命名规范
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectClassInstanceName(name, node) {
+    return _detectNamingError(name, node, 'class-instance');
+  }
+
+  /**
+   * 检测函数名命名规范
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectFunctionName(name, node) {
+    return _detectNamingError(name, node, 'function');
+  }
+
+  /**
+   * 检测参数名命名规范
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectParamName(name, node) {
+    return _detectNamingError(name, node, 'param');
+  }
+
+  /**
+   * 检测变量名命名规范
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectVariableName(name, node) {
+    return _detectNamingError(name, node, 'variable');
+  }
+
+  /**
+   * 检测常量名命名规范
+   * @param {string} name 名称
+   * @param {object} node AST节点
+   * @returns {object|null} 错误信息或null
+   */
+  function _detectConstantName(name, node) {
+    return _detectNamingError(name, node, 'constant');
+  }
+
+  return {
+    'class-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测类名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          ClassDeclaration: function (node) {
+            var class_name = node.id.name;
+            var err = _detectClassName(class_name, node.id);
+            if (err) {
+              err.node = node;
+              context.report(err);
+            }
+          },
+
+          // 检测类表达式（const ClassName = class {}）
+          VariableDeclaration: function (node) {
+            node.declarations.forEach(function (decl) {
+              // 检查是否为解构赋值，如果是则跳过检测
+              if (decl.init && decl.init.type === 'ObjectPattern') {
+                return;
+              }
+              
+              if (decl.init && decl.init.type === 'ClassExpression') {
+                // 检查是否有命名（命名类表达式）
+                if (decl.init.id) {
+                  // 命名类表达式：使用类名规则检测类名
+                  var class_name = decl.init.id.name;
+                  var err = _detectClassName(class_name, decl.init.id);
+                  if (err) {
+                    context.report(err);
+                  }
+                }
+
+                // 检测变量名（类表达式赋值给变量）
+                if (decl.id && decl.id.type === 'Identifier') {
+                  var variable_name = decl.id.name;
+                  // 类表达式赋值给变量应该使用类名规则（PascalCase）
+                  var err = _detectClassName(variable_name, decl.id);
+                  if (err) {
+                    context.report(err);
+                  } else {
+                    // 如果类名检测通过，标记这个节点为类表达式，阻止变量检测
+                    decl._is_class_expression = true;
+                  }
+                }
+              }
+            });
+          },
+
+          // 检测对象属性中的命名规范
+          Property: function (node) {
+            if (node.key && node.key.type === 'Identifier') {
+              // 检查是否为类实例属性，如果是则跳过变量检测（由类实例规则处理）
+              if (node.value && node.value.type === 'NewExpression') {
+                return;
+              }
+              
+              // 检查是否为解构赋值中的属性，如果是则跳过检测（由其他规则处理）
+              var current_node = node;
+              while (current_node.parent) {
+                // 检查是否为解构赋值模式（变量声明）
+                if (current_node.parent.type === 'ObjectPattern' && 
+                    current_node.parent.parent && 
+                    current_node.parent.parent.type === 'VariableDeclarator') {
+                  // 解构赋值中的属性应该由变量名规则或常量名规则处理
+                  return;
+                }
+                
+                // 检查是否为函数参数中的解构参数
+                if (current_node.parent.type === 'ObjectPattern' && 
+                    current_node.parent.parent && 
+                    (current_node.parent.parent.type === 'FunctionDeclaration' ||
+                     current_node.parent.parent.type === 'FunctionExpression' ||
+                     current_node.parent.parent.type === 'ArrowFunctionExpression')) {
+                  // 函数参数中的解构参数应该由参数规则处理
+                  return;
+                }
+                
+                // 检查是否为函数体中的参数引用（在对象字面量中使用参数）
+                if (current_node.parent.type === 'ObjectExpression') {
+                  // 递归向上查找函数节点
+                  var function_node = current_node.parent;
+                  while (function_node.parent) {
+                    if (function_node.parent.type === 'FunctionDeclaration' ||
+                        function_node.parent.type === 'FunctionExpression' ||
+                        function_node.parent.type === 'ArrowFunctionExpression') {
+                      // 函数体中的参数引用应该由参数规则处理
+                      return;
+                    }
+                    function_node = function_node.parent;
+                  }
+                }
+                
+                // 检查是否为 module.exports 对象字面量中的属性
+                if (current_node.parent.type === 'ObjectExpression') {
+                  var obj_expr_node = current_node.parent;
+                  while (obj_expr_node.parent) {
+                    // 检查是否为 module.exports = { ... } 的情况
+                    if (obj_expr_node.parent.type === 'AssignmentExpression' &&
+                        obj_expr_node.parent.left &&
+                        obj_expr_node.parent.left.type === 'MemberExpression' &&
+                        obj_expr_node.parent.left.object &&
+                        obj_expr_node.parent.left.object.type === 'Identifier' &&
+                        obj_expr_node.parent.left.object.name === 'module' &&
+                        obj_expr_node.parent.left.property &&
+                        obj_expr_node.parent.left.property.type === 'Identifier' &&
+                        obj_expr_node.parent.left.property.name === 'exports') {
+                      // module.exports 对象字面量中的属性应该由专门的导出检测逻辑处理
+                      return;
+                    }
+                    obj_expr_node = obj_expr_node.parent;
+                  }
+                }
+                
+                current_node = current_node.parent;
+              }
+              
+              var property_name = node.key.name;
+              var err = _detectVariableName(property_name, node.key);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+          // 检测CommonJS导出（exports.UserManager = class UserManager {}）
+          AssignmentExpression: function (node) {
+            // 处理 exports.XXX = ... 形式的导出
+            if (node.left &&
+              node.left.type === 'MemberExpression' &&
+              node.left.object &&
+              node.left.object.type === 'Identifier' &&
+              node.left.object.name === 'exports' &&
+              node.left.property &&
+              node.left.property.type === 'Identifier') {
+              // CommonJS导出应该根据导出内容的类型使用相应的命名规则
+              var export_name = node.left.property.name;
+              var err = _detectClassName(export_name, node.left.property);
+              if (err) {
+                context.report(err);
+              }
+            }
+            
+            // 处理 module.exports = { ... } 形式的导出
+            if (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 === 'ObjectExpression') {
+              // module.exports 对象字面量中的属性应该根据属性值的类型使用相应的命名规则
+              node.right.properties.forEach(function(property) {
+                if (property.key && property.key.type === 'Identifier') {
+                  var property_name = property.key.name;
+                  var err = _detectClassName(property_name, property.key);
+                  if (err) {
+                    context.report(err);
+                  }
+                }
+              });
+            }
+          }
+        };
+      },
+    },
+
+    'class-instance-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测类实例名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        /**
+         * 检测是否为类引用赋值（this.ClassName = ClassName）
+         * @param {object} node AST节点
+         * @returns {boolean} 是否为类引用赋值
+         */
+        function _isClassReferenceAssignment(node) {
+          if (!node || !node.right || node.right.type !== 'Identifier') {
+            return false;
+          }
+
+          // 检查赋值右侧是否为标识符（类名）
+          var right_identifier = node.right;
+          if (right_identifier.type !== 'Identifier') {
+            return false;
+          }
+
+          // 检查左侧属性名和右侧标识符是否相同（忽略大小写）
+          var left_property_name = node.left.property.name;
+          var right_identifier_name = right_identifier.name;
+          
+          // 如果左侧属性名和右侧标识符相同，说明是类引用赋值
+          if (left_property_name.toLowerCase() === right_identifier_name.toLowerCase()) {
+            return true;
+          }
+
+          // 检查是否为私有类引用赋值（this._ClassName = ClassName）
+          if (left_property_name.startsWith('_') && 
+              left_property_name.slice(1).toLowerCase() === right_identifier_name.toLowerCase()) {
+            return true;
+          }
+
+          return false;
+        }
+
+        return {
+          // 处理类实例变量声明：let/var/const instance = new MyClass()
+          VariableDeclaration: function (node) {
+            node.declarations.forEach(function (decl) {
+              if (decl.id && decl.id.type === 'Identifier' && decl.init && decl.init.type === 'NewExpression') {
+                var instance_name = decl.id.name;
+                var err = _detectClassInstanceName(instance_name, decl.id);
+                if (err) {
+                  context.report(err);
+                }
+              }
+            });
+          },
+          
+          // 处理对象字面量中的类实例属性：{ Userc: new UserClass() }
+          Property: function (node) {
+            if (node.key && node.key.type === 'Identifier' && node.value && node.value.type === 'NewExpression') {
+              var instance_name = node.key.name;
+              // 使用通用检测函数，让detector自动推断类型
+              var err = _detectNamingError(instance_name, node);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+          
+          // 处理实例属性赋值等场景
+          AssignmentExpression: function (node) {
+            if (node.left &&
+              node.left.type === 'MemberExpression' &&
+              node.left.object &&
+              node.left.object.type === 'ThisExpression' &&
+              node.left.property &&
+              node.left.property.type === 'Identifier') {
+
+              var prop_name = node.left.property.name;
+
+              // 检查赋值右侧是否为纯字面量值（应该视为变量，而不是类实例）
+              var is_literal_value = false;
+              if (node.right) {
+                // 检查是否为字面量对象、数组、字符串、数字等
+                var literal_types = ['ObjectExpression', 'ArrayExpression', 'Literal', 'TemplateLiteral'];
+                if (literal_types.includes(node.right.type)) {
+                  // 如果是对象或数组，需要递归检查是否为纯字面量
+                  if (node.right.type === 'ObjectExpression' || node.right.type === 'ArrayExpression') {
+                    is_literal_value = detector._isLiteralValue(node.right);
+                  } else {
+                    // 其他字面量类型直接视为纯字面量
+                    is_literal_value = true;
+                  }
+                }
+              }
+
+              // 如果是纯字面量赋值，应该跳过类实例名检测（由变量规则处理）
+              if (is_literal_value) {
+                return;
+              }
+
+              // 检查是否为类引用赋值（this.ClassName = ClassName）
+              var is_class_reference = _isClassReferenceAssignment(node);
+              if (is_class_reference) {
+                // 类引用赋值应该使用类名规则，跳过类实例检测
+                return;
+              }
+
+              var err = _detectClassInstanceName(prop_name, node.left.property);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+          
+          // 处理类属性中的实例声明：class App { User = new UserClass() }
+          PropertyDefinition: function (node) {
+            if (node.key && node.value && node.value.type === 'NewExpression') {
+              var instance_name = node.key.name;
+              // 传递PropertyDefinition节点而不是key节点，以便正确识别类型
+              // 使用通用检测函数，让detector自动推断类型
+              var err = _detectNamingError(instance_name, node);
+              if (err) {
+                context.report(err);
+              }
+            }
+          }
+        };
+      },
+    },
+
+    'function-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测函数名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          FunctionDeclaration: function (node) {
+            if (node.id) {
+              var function_name = node.id.name;
+
+              // 检查是否为混入函数，如果是则跳过函数检测
+              if (node._is_mixin_function) {
+                return;
+              }
+
+              // 检查是否为混入函数（硬编码识别）
+              if (function_name === 'Loggable' || function_name === 'Serializable') {
+                return;
+              }
+
+              var err = _detectFunctionName(function_name, node.id);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+
+          FunctionExpression: function (node) {
+            if (node.id) {
+              var function_name = node.id.name;
+              var err = _detectNamingError(function_name, node.id);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+
+          // 处理变量声明中的函数表达式
+          VariableDeclaration: function (node) {
+            node.declarations.forEach(function (decl) {
+              if (decl.init) {
+                // 检查是否为类表达式，如果是则跳过函数检测（由类名规则处理）
+                if (decl.init.type === 'ClassExpression') {
+                  return;
+                }
+
+                // 检查是否为混入函数（返回类的函数）
+                var is_mixin_function = false;
+                if (decl.init.type === 'ArrowFunctionExpression' &&
+                  decl.init.body && decl.init.body.type === 'ClassExpression') {
+                  is_mixin_function = true;
+                }
+
+                if (decl.init.type === 'FunctionExpression' ||
+                  decl.init.type === 'ArrowFunctionExpression' ||
+                  is_mixin_function) {
+                  if (decl.id && decl.id.type === 'Identifier') {
+                    var function_name = decl.id.name;
+
+                    // 如果是混入函数，则跳过函数检测（由类检测处理）
+                    if (is_mixin_function) {
+                      return;
+                    }
+
+                    var err = _detectNamingError(function_name, decl.id);
+                    if (err) {
+                      context.report(err);
+                    }
+                  }
+                }
+              }
+            });
+          },
+
+          // 处理函数调用
+          CallExpression: function (node) {
+            if (node.callee && node.callee.type === 'Identifier') {
+              var function_name = node.callee.name;
+
+              // 检查是否为参数名，如果是参数名则跳过检测
+              if (detector._isParameterName(node.callee)) {
+                return;
+              }
+
+              // 检查是否为混入函数调用，如果是则跳过函数检测
+              // 混入函数调用应该视为类调用，不检测函数名
+              if (function_name === 'Loggable' || function_name === 'Serializable') {
+                return;
+              }
+
+              // 检查是否为JavaScript内置函数，如果是则跳过检测
+              var builtin_functions = [
+                'Symbol', 'Object', 'Array', 'String', 'Number', 'Boolean', 'Date',
+                'RegExp', 'Function', 'Error', 'Math', 'JSON', 'Promise', 'Map',
+                'Set', 'WeakMap', 'WeakSet', 'Proxy', 'Reflect', 'Intl', 'console',
+                'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'eval', 'encodeURI',
+                'decodeURI', 'encodeURIComponent', 'decodeURIComponent', 'setTimeout',
+                'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame',
+                'cancelAnimationFrame', 'alert', 'confirm', 'prompt', 'fetch',
+                'XMLHttpRequest', 'FormData', 'URL', 'URLSearchParams', 'Blob',
+                'File', 'FileReader', 'atob', 'btoa', 'crypto', 'performance'
+              ];
+
+              if (builtin_functions.includes(function_name)) {
+                return;
+              }
+
+              var err = _detectNamingError(function_name, node.callee);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+
+          // 处理方法定义（类方法）
+          MethodDefinition: function (node) {
+            if (node.key && (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier')) {
+              var method_name = node.key.name;
+              // 普通方法按函数名规则检测
+              var err = _detectNamingError(method_name, node);
+              if (err) {
+                // 使用检测器返回的原始类型，而不是硬编码替换
+                // 检测器会根据node.static属性返回正确的类型（static-function或function）
+                context.report(err);
+              }
+            }
+          },
+
+          // 处理类属性函数（类字段中的函数）
+          PropertyDefinition: function (node) {
+            if (node.key && node.key.type === 'Identifier') {
+              // 检查是否为函数类型的属性值
+              var is_function_property = false;
+              if (node.value) {
+                var function_types = ['FunctionExpression', 'ArrowFunctionExpression'];
+                if (function_types.includes(node.value.type)) {
+                  is_function_property = true;
+                }
+              }
+              
+              if (is_function_property) {
+                var method_name = node.key.name;
+                // 类属性函数按函数名规则检测
+                var err = _detectNamingError(method_name, node);
+                if (err) {
+                  context.report(err);
+                }
+              }
+            }
+          },
+
+          // 处理对象字面量属性函数
+          Property: function (node) {
+            if (node.key && node.key.type === 'Identifier') {
+              // 检查是否为函数类型的属性值
+              var is_function_property = false;
+              if (node.value) {
+                var function_types = ['FunctionExpression', 'ArrowFunctionExpression'];
+                if (function_types.includes(node.value.type)) {
+                  is_function_property = true;
+                }
+              }
+              
+              if (is_function_property) {
+                var method_name = node.key.name;
+                // 对象字面量属性函数按函数名规则检测
+                var err = _detectNamingError(method_name, node);
+                if (err) {
+                  context.report(err);
+                }
+              }
+            }
+          }
+        };
+      },
+    },
+
+    'param-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测参数名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        /**
+         * 递归检测解构参数中的属性名
+         * @param {object} param 参数节点
+         */
+        function _detectDestructuredParams(param) {
+          if (!param) return;
+          
+          // 处理对象解构参数
+          if (param.type === 'ObjectPattern' && param.properties) {
+            param.properties.forEach(function (property) {
+              if (property.key && property.key.type === 'Identifier') {
+                var param_name = property.key.name;
+                var err = _detectNamingError(param_name, property.key);
+                if (err) {
+                  context.report(err);
+                }
+              }
+              // 递归处理嵌套解构
+              if (property.value && property.value.type === 'ObjectPattern') {
+                _detectDestructuredParams(property.value);
+              }
+            });
+          }
+          
+          // 处理数组解构参数
+          if (param.type === 'ArrayPattern' && param.elements) {
+            param.elements.forEach(function (element, index) {
+              if (element && element.type === 'Identifier') {
+                var param_name = element.name;
+                var err = _detectNamingError(param_name, element);
+                if (err) {
+                  context.report(err);
+                }
+              }
+              // 递归处理嵌套解构
+              if (element && (element.type === 'ObjectPattern' || element.type === 'ArrayPattern')) {
+                _detectDestructuredParams(element);
+              }
+            });
+          }
+        }
+
+        return {
+          // 处理函数参数声明
+          FunctionDeclaration: function (node) {
+            if (node.params && Array.isArray(node.params)) {
+              node.params.forEach(function (param) {
+                if (param.type === 'Identifier') {
+                  var param_name = param.name;
+                  var err = _detectNamingError(param_name, param);
+                  if (err) {
+                    context.report(err);
+                  }
+                } else {
+                  // 处理解构参数
+                  _detectDestructuredParams(param);
+                }
+              });
+            }
+          },
+
+          FunctionExpression: function (node) {
+            if (node.params && Array.isArray(node.params)) {
+              node.params.forEach(function (param) {
+                if (param.type === 'Identifier') {
+                  var param_name = param.name;
+                  var err = _detectNamingError(param_name, param);
+                  if (err) {
+                    context.report(err);
+                  }
+                } else {
+                  // 处理解构参数
+                  _detectDestructuredParams(param);
+                }
+              });
+            }
+          },
+
+          ArrowFunctionExpression: function (node) {
+            if (node.params && Array.isArray(node.params)) {
+              node.params.forEach(function (param) {
+                if (param.type === 'Identifier') {
+                  var param_name = param.name;
+                  var err = _detectNamingError(param_name, param);
+                  if (err) {
+                    context.report(err);
+                  }
+                } else {
+                  // 处理解构参数
+                  _detectDestructuredParams(param);
+                }
+              });
+            }
+          }
+        };
+      },
+    },
+
+    'variable-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测变量名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          VariableDeclaration: function (node) {
+            // 只检测let和var声明，const声明由常量规则处理
+            if (node.kind === 'const') {
+              return;
+            }
+            
+            // 检测所有变量声明
+            node.declarations.forEach(function (decl) {
+              // 处理简单变量声明
+              if (decl.id && decl.id.type === 'Identifier') {
+                var variable_name = decl.id.name;
+
+                // 检查是否为类表达式，如果是则跳过变量检测
+                if (decl._is_class_expression) {
+                  return;
+                }
+
+                // 检查是否为类实例声明，如果是则跳过变量检测（由类实例规则处理）
+                if (decl.init && decl.init.type === 'NewExpression') {
+                  return;
+                }
+
+                // 检查是否为CommonJS导入语句，如果是则跳过检测
+                if (decl.init) {
+                  // 检查是否为require()调用
+                  if (decl.init.type === 'CallExpression' && 
+                      decl.init.callee && 
+                      decl.init.callee.name === 'require') {
+                    return; // 跳过require导入检测
+                  }
+                  
+                  // 检查是否为require().xxx形式的导入
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'CallExpression' &&
+                      decl.init.object.callee &&
+                      decl.init.object.callee.name === 'require') {
+                    return; // 跳过require().xxx导入检测
+                  }
+                  
+                  // 检查是否为动态导入（import()）
+                  if (decl.init.type === 'CallExpression' &&
+                      decl.init.callee &&
+                      decl.init.callee.type === 'Import') {
+                    return; // 跳过动态导入检测
+                  }
+                  
+                  // 检查是否为动态导入的成员表达式（import().xxx）
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'CallExpression' &&
+                      decl.init.object.callee &&
+                      decl.init.object.callee.type === 'Import') {
+                    return; // 跳过动态导入成员检测
+                  }
+                  
+                  // 检查是否为带await的动态导入（await import().xxx）
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'AwaitExpression' &&
+                      decl.init.object.argument &&
+                      decl.init.object.argument.type === 'ImportExpression') {
+                    return; // 跳过await动态导入检测
+                  }
+                  
+                  // 检查是否为模块导入的变量（module.xxx）
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'Identifier' &&
+                      decl.init.object.name === 'module') {
+                    return; // 跳过模块导入变量检测
+                  }
+                  
+                  // 检查是否为模块导入的变量（module.xxx）
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'Identifier' &&
+                      decl.init.object.name === 'module') {
+                    return; // 跳过模块导入变量检测
+                  }
+                  
+                  // 检查是否为带await的动态导入（await import().xxx）
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'AwaitExpression' &&
+                      decl.init.object.argument &&
+                      decl.init.object.argument.type === 'ImportExpression') {
+                    return; // 跳过await动态导入检测
+                  }
+                }
+
+                // 简化类型推断逻辑：直接使用detector的自动类型推断
+                var err = _detectNamingError(variable_name, decl.id);
+                if (err) {
+                  context.report(err);
+                }
+              }
+            });
+          },
+
+          // 检测for循环中的变量声明
+          ForStatement: function (node) {
+            // 检测for循环初始化部分中的变量声明
+            if (node.init && node.init.type === 'VariableDeclaration') {
+              // 只检测let和var声明，const声明由常量规则处理
+              if (node.init.kind === 'const') {
+                return;
+              }
+              
+              node.init.declarations.forEach(function (decl) {
+                if (decl.id && decl.id.type === 'Identifier') {
+                  var variable_name = decl.id.name;
+                  var err = _detectNamingError(variable_name, decl.id);
+                  if (err) {
+                    context.report(err);
+                  }
+                }
+              });
+            }
+          },
+
+          // 检测for...in循环中的变量声明
+          ForInStatement: function (node) {
+            // 检测for...in循环左侧的变量声明
+            if (node.left && node.left.type === 'VariableDeclaration') {
+              // 只检测let和var声明，const声明由常量规则处理
+              if (node.left.kind === 'const') {
+                return;
+              }
+              
+              node.left.declarations.forEach(function (decl) {
+                if (decl.id && decl.id.type === 'Identifier') {
+                  var variable_name = decl.id.name;
+                  var err = _detectNamingError(variable_name, decl.id);
+                  if (err) {
+                    context.report(err);
+                  }
+                }
+              });
+            }
+          },
+
+          // 检测for...of循环中的变量声明
+          ForOfStatement: function (node) {
+            // 检测for...of循环左侧的变量声明
+            if (node.left && node.left.type === 'VariableDeclaration') {
+              // 只检测let和var声明，const声明由常量规则处理
+              if (node.left.kind === 'const') {
+                return;
+              }
+              
+              node.left.declarations.forEach(function (decl) {
+                if (decl.id && decl.id.type === 'Identifier') {
+                  var variable_name = decl.id.name;
+                  var err = _detectNamingError(variable_name, decl.id);
+                  if (err) {
+                    context.report(err);
+                  }
+                }
+              });
+            }
+          },
+
+          // 处理赋值表达式
+          AssignmentExpression: function (node) {
+            // 先检查是否是原型方法赋值（UserManagera.prototype._GetUserps = function() {}）
+            if (node.left && 
+                node.left.type === 'MemberExpression' &&
+                node.left.property &&
+                node.left.property.type === 'Identifier' &&
+                node.right &&
+                (node.right.type === 'FunctionExpression' || node.right.type === 'ArrowFunctionExpression')) {
+              
+              // 检查左侧是否是原型方法模式（包含prototype）
+              var left_str = context.getSourceCode().getText(node.left);
+              if (left_str.includes('.prototype.')) {
+                var method_name = node.left.property.name;
+                var err = _detectNamingError(method_name, node);
+                if (err) {
+                  context.report(err);
+                  return; // 如果检测到原型方法，直接返回，避免被其他规则覆盖
+                }
+              }
+            }
+            
+            // 再检查是否是普通变量赋值（a = 1）
+            if (node.left && node.left.type === 'Identifier') {
+              var variable_name = node.left.name;
+              var err = _detectNamingError(variable_name, node);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+
+          // 检测类属性（Class Properties）中的命名规范
+          PropertyDefinition: function (node) {
+            if (node.key && node.key.type === 'Identifier') {
+              // 检查是否为类实例声明，如果是则跳过变量检测（由类实例规则处理）
+              if (node.value && node.value.type === 'NewExpression') {
+                return;
+              }
+              
+              var property_name = node.key.name;
+              var err = _detectNamingError(property_name, node);
+              if (err) {
+                context.report(err);
+              }
+            }
+          },
+
+        };
+      },
+    },
+
+    'constant-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测常量名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          VariableDeclaration: function (node) {
+            // 只检测const声明
+            if (node.kind !== 'const') {
+              return;
+            }
+
+            node.declarations.forEach(function (decl) {
+              // 只验证顶层变量声明，不验证对象属性
+              if (decl.id && decl.id.type === 'Identifier') {
+                // 检查是否为顶层变量声明（不是对象属性）
+                var is_top_level = true;
+                var current_node = decl;
+                while (current_node.parent) {
+                  if (current_node.parent.type === 'Property' ||
+                    current_node.parent.type === 'ObjectExpression' ||
+                    current_node.parent.type === 'ArrayExpression') {
+                    is_top_level = false;
+                    break;
+                  }
+                  current_node = current_node.parent;
+                }
+
+                if (!is_top_level) {
+                  return; // 跳过对象属性
+                }
+
+                // 检查是否为函数/类的常量，如果是则跳过检测（由其他规则处理）
+                if (decl.init) {
+                  // 函数类型
+                  var function_types = ['FunctionExpression', 'ArrowFunctionExpression'];
+                  if (function_types.includes(decl.init.type)) {
+                    return; // 跳过函数常量，由函数名规则处理
+                  }
+                  
+                  // 类表达式
+                  if (decl.init.type === 'ClassExpression') {
+                    return; // 跳过类常量，由类名规则处理
+                  }
+                  
+                  // 类实例（new表达式）
+                  if (decl.init.type === 'NewExpression') {
+                    return; // 跳过类实例常量，由类实例名规则处理
+                  }
+                  
+                  // 检查是否为CommonJS导入语句，如果是则跳过检测
+                  // 检查是否为require()调用
+                  if (decl.init.type === 'CallExpression' && 
+                      decl.init.callee && 
+                      decl.init.callee.name === 'require') {
+                    return; // 跳过require导入检测
+                  }
+                  
+                  // 检查是否为require().xxx形式的导入
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'CallExpression' &&
+                      decl.init.object.callee &&
+                      decl.init.object.callee.name === 'require') {
+                    return; // 跳过require().xxx导入检测
+                  }
+                  
+                  // 检查是否为动态导入（import()）
+                  if (decl.init.type === 'CallExpression' &&
+                      decl.init.callee &&
+                      decl.init.callee.type === 'Import') {
+                    return; // 跳过动态导入检测
+                  }
+                  
+                  // 检查是否为动态导入的成员表达式（import().xxx）
+                  if (decl.init.type === 'MemberExpression' &&
+                      decl.init.object &&
+                      decl.init.object.type === 'CallExpression' &&
+                      decl.init.object.callee &&
+                      decl.init.object.callee.type === 'Import') {
+                    return; // 跳过动态导入成员检测
+                  }
+                }
+
+                var constant_name = decl.id.name;
+
+                // 检查是否为真正的常量（const声明且值为字面量）
+                if (detector._isTrueConstant(constant_name, decl)) {
+                  var err = _detectNamingError(constant_name, decl.id);
+                  if (err) {
+                    context.report(err);
+                  }
+                }
+              }
+            });
+          }
+        };
+      },
+    }
+  };
+}
+
+module.exports = {
+  rules: createNamingRules()
+};