mm_eslint 1.4.4 → 1.4.5

package/index.js

@@ -1,1045 +1,344 @@
-/**
- * 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()
-};
+/**
+ * ESLint命名规范检测插件
+ * 版本: 2.0.0 - 模块化重构版，职责分离
+ */
+const { Handler } = require('./handler');
+
+/**
+ * 规则定义类
+ * 负责定义ESLint规则配置
+ */
+class Rules {
+  /**
+   * 构造函数
+   */
+  constructor() {
+    this.handler = new Handler();
+  }
+
+  /**
+   * 创建类名规则
+   * @returns {object} 类名规则配置
+   */
+  createClassNameRule() {
+    var handler = this.handler;
+    
+    return {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测类名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          ClassDeclaration: function (node) {
+            handler.handleClassDeclaration(context, node, node, 'class');
+          },
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'class');
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'class');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'class');
+          },
+          ExportDefaultDeclaration: function (node) {
+            handler.handleExportDefaultDeclaration(context, node, node, 'class');
+          },
+          ExportNamedDeclaration: function (node) {
+            handler.handleExportNamedDeclaration(context, node, node, 'class');
+          },
+          ClassExpression: function (node) {
+            handler.handleClassExpression(context, node, node, 'class');
+          },
+          ImportDeclaration: function (node) {
+            handler.handleImportDeclaration(context, node, node, 'class');
+          },
+          Identifier: function (node) {
+            handler.handleIdentifier(context, node, node, 'class');
+          }
+        };
+      },
+    };
+  }
+
+  /**
+   * 创建类实例名规则
+   * @returns {object} 类实例名规则配置
+   */
+  createClassInstanceNameRule() {
+    var handler = this.handler;
+    
+    return {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测类实例名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'class-instance');
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'class-instance');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'class-instance');
+          },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'class-instance');
+          }
+        };
+      },
+    };
+  }
+
+  /**
+   * 创建函数名规则
+   * @returns {object} 函数名规则配置
+   */
+  createFunctionNameRule() {
+    var handler = this.handler;
+    
+    return {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测函数名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          FunctionDeclaration: function (node) {
+            handler.handleFunctionDeclaration(context, node, node, 'function');
+          },
+          FunctionExpression: function (node) {
+            handler.handleFunctionExpression(context, node, node, 'function');
+          },
+          ArrowFunctionExpression: function (node) {
+            handler.handleArrowFunctionExpression(context, node, node, 'function');
+          },
+          CallExpression: function (node) {
+            handler.handleCallExpression(context, node, node, 'function');
+          },
+          MethodDefinition: function (node) {
+            handler.handleMethodDefinition(context, node, node, 'function');
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'function');
+          },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'function');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'function');
+          },
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'function');
+          },
+        };
+      },
+    };
+  }
+
+  /**
+   * 创建变量名规则
+   * @returns {object} 变量名规则配置
+   */
+  createVariableNameRule() {
+    var handler = this.handler;
+    
+    return {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测变量名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'variable');
+          },
+          ForStatement: function (node) {
+            if (node.init && node.init.type === 'VariableDeclaration') {
+              handler.handleVariableDeclaration(context, node, node.init, 'variable');
+            }
+          },
+          ForInStatement: function (node) {
+            if (node.left && node.left.type === 'VariableDeclaration') {
+              handler.handleVariableDeclaration(context, node, node.left, 'variable');
+            }
+          },
+          ForOfStatement: function (node) {
+            if (node.left && node.left.type === 'VariableDeclaration') {
+              handler.handleVariableDeclaration(context, node, node.left, 'variable');
+            }
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'variable');
+          },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'variable');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'variable');
+          }
+        };
+      },
+    };
+  }
+
+  /**
+   * 创建常量名规则
+   * @returns {object} 常量名规则配置
+   */
+  createConstantNameRule() {
+    var handler = this.handler;
+    
+    return {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测常量名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          VariableDeclaration: function (node) {
+            handler.handleVariableDeclaration(context, node, node, 'constant');
+          },
+          Property: function (node) {
+            handler.handleProperty(context, node, node, 'constant');
+          },
+          PropertyDefinition: function (node) {
+            handler.handlePropertyDefinition(context, node, node, 'constant');
+          },
+          AssignmentExpression: function (node) {
+            handler.handleAssignmentExpression(context, node, node, 'constant');
+          }
+        };
+      },
+    };
+  }
+
+  /**
+   * 创建参数名规则
+   * @returns {object} 参数名规则配置
+   */
+  createParamNameRule() {
+    var handler = this.handler;
+    
+    return {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测参数名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+      },
+      create: function (context) {
+        return {
+          FunctionDeclaration: function (node) {
+            if (node.params && node.params.length > 0) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.type === 'Identifier') {
+                  var result = handler.detector.detect(param, param.name);
+                  if (result) {
+                    result.node = param;
+                    result.fix = handler.fix.createParamFixFunction(context, param, result);
+                    context.report(result);
+                  }
+                }
+              }
+            }
+          },
+          FunctionExpression: function (node) {
+            if (node.params && node.params.length > 0) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.type === 'Identifier') {
+                  var result = handler.detector.detect(param, param.name);
+                  if (result) {
+                    result.node = param;
+                    result.fix = handler.fix.createParamFixFunction(context, param, result);
+                    context.report(result);
+                  }
+                }
+              }
+            }
+          },
+          ArrowFunctionExpression: function (node) {
+            if (node.params && node.params.length > 0) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.type === 'Identifier') {
+                  var result = handler.detector.detect(param, param.name);
+                  if (result) {
+                    result.node = param;
+                    result.fix = handler.fix.createParamFixFunction(context, param, result);
+                    context.report(result);
+                  }
+                }
+              }
+            }
+          }
+        };
+      },
+    };
+  }
+
+  /**
+   * 获取所有规则
+   * @returns {object} 所有规则配置
+   */
+  getAllRules() {
+    return {
+      'class-name': this.createClassNameRule(),
+      'class-instance-name': this.createClassInstanceNameRule(),
+      'function-name': this.createFunctionNameRule(),
+      'variable-name': this.createVariableNameRule(),
+      'constant-name': this.createConstantNameRule(),
+      'param-name': this.createParamNameRule()
+    };
+  }
+}
+
+/**
+ * 创建ESLint规则配置
+ * @returns {object} ESLint规则配置对象
+ */
+function createNamingRules() {
+  var rules = new Rules();
+  return rules.getAllRules();
+}
+
+module.exports = createNamingRules();