mm_eslint 1.4.0 → 1.4.2

package/index.js

@@ -14,6 +14,75 @@ 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: {
@@ -23,6 +92,7 @@ function createNamingRules() {
           category: 'Stylistic Issues',
           recommended: true,
         },
+        fixable: 'code',
         schema: [],
       },
       create: function (context) {
@@ -31,10 +101,23 @@ function createNamingRules() {
             var class_name = node.id.name;
             var err = detector._checkClassName(class_name, node);
             if (err) {
-              context.report({
+              // 获取修复建议
+              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);
             }
           },
         };
@@ -49,6 +132,7 @@ function createNamingRules() {
           category: 'Stylistic Issues',
           recommended: true,
         },
+        fixable: 'code',
         schema: [],
       },
       create: function (context) {
@@ -58,10 +142,26 @@ function createNamingRules() {
               var function_name = node.id.name;
               var err = detector._checkFunctionName(function_name, node);
               if (err) {
-                context.report({
+                // 获取修复建议
+                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);
               }
             }
           },
@@ -70,10 +170,90 @@ function createNamingRules() {
               var function_name = node.id.name;
               var err = detector._checkFunctionName(function_name, node);
               if (err) {
-                context.report({
+                // 获取修复建议
+                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);
               }
             }
           },
@@ -89,6 +269,7 @@ function createNamingRules() {
           category: 'Stylistic Issues',
           recommended: true,
         },
+        fixable: 'code',
         schema: [],
       },
       create: function (context) {
@@ -98,10 +279,113 @@ function createNamingRules() {
               var method_name = node.key.name;
               var err = detector._checkMethodName(method_name, node);
               if (err) {
-                context.report({
+                // 获取修复建议
+                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);
               }
             }
           },
@@ -117,6 +401,7 @@ function createNamingRules() {
           category: 'Stylistic Issues',
           recommended: true,
         },
+        fixable: 'code',
         schema: [],
       },
       create: function (context) {
@@ -130,10 +415,23 @@ function createNamingRules() {
                   var variable_name = decl.id.name;
                   var err = detector._checkVariableName(variable_name, decl);
                   if (err) {
-                    context.report({
+                    // 获取修复建议
+                    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
@@ -143,10 +441,23 @@ function createNamingRules() {
                       var variable_name = property.key.name;
                       var err = detector._checkVariableName(variable_name, decl);
                       if (err) {
-                        context.report({
+                        // 获取修复建议
+                        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);
                       }
                     }
                   });
@@ -158,10 +469,23 @@ function createNamingRules() {
                       var variable_name = element.name;
                       var err = detector._checkVariableName(variable_name, decl);
                       if (err) {
-                        context.report({
+                        // 获取修复建议
+                        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);
                       }
                     }
                   });
@@ -181,60 +505,19 @@ function createNamingRules() {
           category: 'Stylistic Issues',
           recommended: true,
         },
+        fixable: 'code',
         schema: [],
       },
       create: function (context) {
         return {
           FunctionDeclaration: function (node) {
-            if (node.params) {
-              for (var i = 0; i < node.params.length; i++) {
-                var param = node.params[i];
-                if (param.name) {
-                  var param_name = param.name;
-                  var err = detector._checkParamName(param_name, param);
-                  if (err) {
-                    context.report({
-                      node: err.node,
-                      message: err.message,
-                    });
-                  }
-                }
-              }
-            }
+            _fixParamAndReferences(context, node, detector);
           },
           FunctionExpression: function (node) {
-            if (node.params) {
-              for (var i = 0; i < node.params.length; i++) {
-                var param = node.params[i];
-                if (param.name) {
-                  var param_name = param.name;
-                  var err = detector._checkParamName(param_name, param);
-                  if (err) {
-                    context.report({
-                      node: err.node,
-                      message: err.message,
-                    });
-                  }
-                }
-              }
-            }
+            _fixParamAndReferences(context, node, detector);
           },
           ArrowFunctionExpression: function (node) {
-            if (node.params) {
-              for (var i = 0; i < node.params.length; i++) {
-                var param = node.params[i];
-                if (param.name) {
-                  var param_name = param.name;
-                  var err = detector._checkParamName(param_name, param);
-                  if (err) {
-                    context.report({
-                      node: err.node,
-                      message: err.message,
-                    });
-                  }
-                }
-              }
-            }
+            _fixParamAndReferences(context, node, detector);
           },
         };
       },
@@ -248,6 +531,7 @@ function createNamingRules() {
           category: 'Stylistic Issues',
           recommended: true,
         },
+        fixable: 'code',
         schema: [],
       },
       create: function (context) {
@@ -260,10 +544,60 @@ function createNamingRules() {
                   var constant_name = decl.id.name;
                   var err = detector._checkConstantName(constant_name, decl, decl.init);
                   if (err) {
-                    context.report({
+                    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
@@ -274,10 +608,49 @@ function createNamingRules() {
                       // 对于解构赋值，使用专门的检测方法
                       var err = detector._checkConstantNameForDestructuring(constant_name, property.key);
                       if (err) {
-                        context.report({
+                        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);
                       }
                     }
                   });
@@ -290,10 +663,37 @@ function createNamingRules() {
                       // 对于解构赋值，使用专门的检测方法
                       var err = detector._checkConstantNameForDestructuring(constant_name, element);
                       if (err) {
-                        context.report({
-                          node: element,
-                          message: err.message,
-                        });
+                        // 根据错误信息确定正确的规则类型
+                      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);
                       }
                     }
                   });
@@ -305,15 +705,16 @@ function createNamingRules() {
       },
     },
 
-    'property-name': {
+    'property-value-name': {
       meta: {
         type: 'suggestion',
         docs: {
-          description: '检测属性名是否符合命名规范',
+          description: '属性值名命名规范检测',
           category: 'Stylistic Issues',
-          recommended: true,
+          recommended: true
         },
-        schema: [],
+        fixable: 'code',
+        schema: []
       },
       create: function (context) {
         return {
@@ -331,21 +732,96 @@ function createNamingRules() {
               return;
             }
             
+            // 传递祖父节点信息，用于第三方库排除检测
+            var parent_info = {
+              node: node.parent,
+              parent: node.parent ? node.parent.parent : null
+            };
+            
             var err = detector._checkPropertyName(
               prop_name,
               node,
               node.value,
-              node.parent,
+              parent_info,
             );
             
-            if (err) {
-              context.report({
+            // 只处理属性值名相关的错误
+            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 &&
@@ -353,6 +829,20 @@ function createNamingRules() {
               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值和未赋值属性的检测
@@ -372,20 +862,436 @@ function createNamingRules() {
                 node.parent,
               );
               
-              if (err) {
-                context.report({
+              // 只处理属性值名相关的错误
+              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(),
 };