mm_eslint 1.5.1 → 1.5.3

package/lib/detector/const_name.js

@@ -10,6 +10,23 @@ class ConstName extends Name {
   }
 }
 
+/**
+ * 判断节点是否在for...of或for...in循环中
+ * @param {Object} node - AST节点
+ * @returns {boolean} 是否在for...of或for...in循环中
+ */
+ConstName.prototype._isInForOfLoop = function (node) {
+  let current_node = node;
+  while (current_node.parent) {
+    // 检查父节点是否为ForOfStatement或ForInStatement
+    if (current_node.parent.type === 'ForOfStatement' || current_node.parent.type === 'ForInStatement') {
+      return true;
+    }
+    current_node = current_node.parent;
+  }
+  return false;
+}
+
 /**
  * 变量声明节点检测函数（常量声明）
  * @param {Object} node - 变量声明节点
@@ -46,6 +63,11 @@ ConstName.prototype.VariableDeclaration = function (node) {
           continue;
         }
 
+        // 排除for...of和for...in循环中的const声明
+        if (this._isInForOfLoop(node)) {
+          continue;
+        }
+
         // 判断是否为常量（包括 Object.freeze() 等情况）
         if (this._isConstantValue(decl.init)) {
           // 检测常量名
@@ -205,6 +227,11 @@ ConstName.prototype._isConstantValue = function (value_node) {
     return false; // await表达式的结果通常是可变的，不是常量
   }
 
+  // 排除条件表达式（三元运算符）
+  if (value_node.type === 'ConditionalExpression') {
+    return false; // 条件表达式的结果在运行时确定，不是常量
+  }
+
   // 默认情况下，如果不是排除的类型，就认为是常量
   return true;
 }

package/lib/detector/variable_name.js

@@ -79,6 +79,19 @@ VariableName.prototype.VariableDeclaration = function (node) {
         // 检测变量名
         let name = decl.id.name;
         
+        // 检查是否在for...of循环中
+        if (this._isInForLoop(node)) {
+          // 在for...of循环中的const声明应该使用let
+          let error = {
+            message: `变量'${name}'应该使用let标签声明而不是const标签声明`,
+            fix: function(fixer) {
+              return fixer.replaceTextRange([node.range[0], node.range[0] + 5], 'let');
+            }
+          };
+          this.report(node, error, 'variable');
+          return error;
+        }
+        
         // 对于const声明，处理右边是CallExpression或AwaitExpression的情况
         if (decl.init) {
           // 对于AwaitExpression，直接处理
@@ -121,6 +134,18 @@ VariableName.prototype.VariableDeclaration = function (node) {
             this.report(node, error, 'variable');
             return error;
           }
+          
+          // 对于ConditionalExpression（条件表达式/三元运算符），直接处理
+          else if (decl.init.type === 'ConditionalExpression') {
+            let error = {
+              message: `变量'${name}'应该使用let标签声明而不是const标签声明`,
+              fix: function(fixer) {
+                return fixer.replaceTextRange([node.range[0], node.range[0] + 5], 'let');
+              }
+            };
+            this.report(node, error, 'variable');
+            return error;
+          }
         }
         // 对于const声明的其他情况，跳过变量规则检测（由常量规则处理）
         return;
@@ -129,32 +154,6 @@ VariableName.prototype.VariableDeclaration = function (node) {
   }
 }
 
-// /**
-//  * 标识符引用节点检测函数（变量引用）
-//  * @param {Object} node - 标识符节点
-//  * @returns {Object|undefined} - 检测结果对象或undefined
-//  */
-// VariableName.prototype.Identifier = function (node) {
-//   // 检测标识符引用（如表达式中的 Name、Age）
-//   if (node.type === 'Identifier') {
-//     let name = node.name;
-    
-//     // 使用精确的类型识别逻辑
-//     let original_type = this._getOriginalType(node, 'Identifier');
-    
-//     // 只有当确实是变量引用时才进行变量命名规则检测
-//     if (original_type === 'variable' || original_type === 'unknown') {
-//       let error = this.check(node, name, original_type);
-      
-//       // 如果检测到错误，报告错误
-//       if (error) {
-//         this.report(node, error, original_type);
-//         return error;
-//       }
-//     }
-//   }
-// };
-
 /**
  * 属性节点检测函数（变量属性）
  * @param {Object} node - 属性节点
@@ -338,6 +337,23 @@ VariableName.prototype.ExportNamedDeclaration = function (node) {
   }
 }
 
+/**
+ * 判断节点是否在for...of或for...in循环中
+ * @param {Object} node - AST节点
+ * @returns {boolean} 是否在for...of或for...in循环中
+ */
+VariableName.prototype._isInForLoop = function (node) {
+  let current_node = node;
+  while (current_node.parent) {
+    // 检查父节点是否为ForOfStatement或ForInStatement
+    if (current_node.parent.type === 'ForOfStatement' || current_node.parent.type === 'ForInStatement') {
+      return true;
+    }
+    current_node = current_node.parent;
+  }
+  return false;
+}
+
 module.exports = {
   VariableName
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_eslint",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "ESLint plugin for personal naming conventions - supports PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules with intelligent recommendations",
   "main": "index.js",
   "keywords": [