mm_eslint 1.4.4 → 1.4.6

package/lib/detector/const_name.js

@@ -0,0 +1,519 @@
+const { Name } = require('./name.js');
+
+/**
+ * 常量名检测器类
+ * 负责检测常量名是否符合命名规范
+ */
+class ConstName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 变量声明节点检测函数（常量声明）
+ * @param {Object} node - 变量声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ConstName.prototype.VariableDeclaration = function (node) {
+  // 判断是否为常量声明（const）
+  if (node.kind === 'const') {
+    for (let i = 0; i < node.declarations.length; i++) {
+      let decl = node.declarations[i];
+      if (decl.id && decl.id.type === 'Identifier') {
+        // 排除类实例：如果右边是 new 表达式，则不是常量
+        if (decl.init && decl.init.type === 'NewExpression') {
+          continue;
+        }
+
+        // 排除正则表达式字面量（RegExp实例）
+        if (decl.init && decl.init.type === 'Literal' && decl.init.regex) {
+          continue;
+        }
+
+        // 排除函数：如果右边是函数表达式或箭头函数，则不是常量
+        if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
+          continue;
+        }
+
+        // 排除类：如果右边是类表达式，则不是常量
+        if (decl.init && decl.init.type === 'ClassExpression') {
+          continue;
+        }
+
+        // 排除函数引用：如果右边是标识符且指向函数，则不是常量
+        if (decl.init && decl.init.type === 'Identifier' && this._isFunctionReference(decl.init)) {
+          continue;
+        }
+
+        // 判断是否为常量（包括 Object.freeze() 等情况）
+        if (this._isConstantValue(decl.init)) {
+          // 检测常量名
+          let name = decl.id.name;
+          let original_type = 'constant';
+          let error = this.check(node, name, original_type);
+          this.report(node, error, original_type);
+
+          if (error) {
+            return error;
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 属性节点检测函数（常量属性）
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ConstName.prototype.Property = function (node) {
+  // 判断是否为常量属性（对象字面量中的常量属性）
+  // 只有当属性在常量对象中时才进行常量检测
+  if (!this._isInConstantObject(node)) {
+    return;
+  }
+
+  // 排除类实例：如果右边是 new 表达式，则不是常量属性
+  if (node.value && node.value.type === 'NewExpression') {
+    return;
+  }
+
+  // 排除函数：如果右边是函数表达式或箭头函数，则不是常量属性
+  if (node.value && (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression')) {
+    return;
+  }
+
+  // 排除类：如果右边是类表达式，则不是常量属性
+  if (node.value && node.value.type === 'ClassExpression') {
+    return;
+  }
+
+  // 判断属性值是否为基本类型或字面量
+  if (this._isPrimitiveOrLiteral(node.value)) {
+    let name = node.key.name;
+    let error = this.check(node, name, 'property-constant');
+    this.report(node, error, 'property-constant');
+    return error;
+  }
+}
+
+/**
+ * 判断节点值是否为基本类型或字面量
+ * @param {Object} value_node - 值节点
+ * @returns {boolean} 是否为基本类型或字面量
+ */
+ConstName.prototype._isPrimitiveOrLiteral = function (value_node) {
+  if (!value_node) {
+    return false;
+  }
+
+  // 基本类型：字符串、数字、布尔值、null、undefined
+  const primitive_types = [
+    'Literal',           // 字面量（字符串、数字、布尔值、正则表达式等）
+    'StringLiteral',     // 字符串字面量
+    'NumericLiteral',    // 数字字面量
+    'BooleanLiteral',    // 布尔字面量
+    'NullLiteral',       // null字面量
+    'RegExpLiteral',     // 正则表达式字面量
+    'TemplateLiteral'    // 模板字符串字面量
+  ];
+
+  // 对象字面量和数组字面量也视为常量
+  const literal_types = [
+    'ObjectExpression',  // 对象字面量
+    'ArrayExpression'    // 数组字面量
+  ];
+
+  return primitive_types.includes(value_node.type) || literal_types.includes(value_node.type);
+}
+
+/**
+ * 判断一个值是否为常量
+ * @param {Object} value_node - 值节点
+ * @returns {boolean} 是否为常量
+ */
+ConstName.prototype._isConstantValue = function (value_node) {
+  if (!value_node) {
+    return true; // 没有初始值也视为常量
+  }
+
+  // 基本类型和字面量都是常量
+  if (this._isPrimitiveOrLiteral(value_node)) {
+    return true;
+  }
+
+  // Object.freeze() 调用是常量
+  if (value_node.type === 'CallExpression' &&
+    value_node.callee &&
+    value_node.callee.type === 'MemberExpression' &&
+    value_node.callee.object &&
+    value_node.callee.object.name === 'Object' &&
+    value_node.callee.property &&
+    value_node.callee.property.name === 'freeze') {
+    return true;
+  }
+
+  // Object.seal() 调用是常量
+  if (value_node.type === 'CallExpression' &&
+    value_node.callee &&
+    value_node.callee.type === 'MemberExpression' &&
+    value_node.callee.object &&
+    value_node.callee.object.name === 'Object' &&
+    value_node.callee.property &&
+    value_node.callee.property.name === 'seal') {
+    return true;
+  }
+
+  // Object.preventExtensions() 调用是常量
+  if (value_node.type === 'CallExpression' &&
+    value_node.callee &&
+    value_node.callee.type === 'MemberExpression' &&
+    value_node.callee.object &&
+    value_node.callee.object.name === 'Object' &&
+    value_node.callee.property &&
+    value_node.callee.property.name === 'preventExtensions') {
+    return true;
+  }
+
+  // 其他情况：标识符引用（需要进一步判断）
+  if (value_node.type === 'Identifier') {
+    // 这里可以进一步判断标识符是否为常量
+    // 暂时返回true，让命名规范检测
+    return true;
+  }
+
+  // 默认情况下，如果不是排除的类型，就认为是常量
+  return true;
+}
+
+/**
+ * 判断节点是否为类定义
+ * @param {Object} node - AST节点
+ * @returns {boolean} 是否为类定义
+ */
+ConstName.prototype._isClassDefinition = function (node) {
+  if (!node) {
+    return false;
+  }
+
+  // 类表达式
+  if (node.type === 'ClassExpression') {
+    return true;
+  }
+
+  // 类声明（通过标识符引用）
+  if (node.type === 'Identifier') {
+    // 检查标识符是否指向类定义
+    // 通过查找同级节点中的类声明来判断
+    let current_node = node;
+    while (current_node.parent) {
+      // 查找同级节点中的类声明
+      if (current_node.parent.body && Array.isArray(current_node.parent.body)) {
+        for (let sibling of current_node.parent.body) {
+          if (sibling.type === 'ClassDeclaration' && sibling.id && sibling.id.name === node.name) {
+            return true;
+          }
+        }
+      }
+      current_node = current_node.parent;
+    }
+  }
+
+  // 其他情况不是类定义
+  return false;
+}
+
+/**
+ * 判断标识符是否指向类实例
+ * @param {Object} node - 标识符节点
+ * @returns {boolean} 是否指向类实例
+ */
+ConstName.prototype._isClassInstanceReference = function (node) {
+  if (!node || node.type !== 'Identifier') {
+    return false;
+  }
+
+  // 查找同级节点中的变量声明，判断是否通过 new 表达式创建
+  let current_node = node;
+  while (current_node.parent) {
+    // 查找同级节点中的变量声明
+    if (current_node.parent.body && Array.isArray(current_node.parent.body)) {
+      for (let sibling of current_node.parent.body) {
+        // 检查变量声明
+        if (sibling.type === 'VariableDeclaration' && sibling.declarations) {
+          for (let decl of sibling.declarations) {
+            if (decl.id && decl.id.type === 'Identifier' && decl.id.name === node.name) {
+              // 检查变量是否通过 new 表达式初始化
+              if (decl.init && decl.init.type === 'NewExpression') {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    }
+    current_node = current_node.parent;
+  }
+
+  return false;
+}
+
+/**
+ * 判断标识符是否指向函数
+ * @param {Object} node - 标识符节点
+ * @returns {boolean} 是否指向函数
+ */
+ConstName.prototype._isFunctionReference = function (node) {
+  if (!node || node.type !== 'Identifier') {
+    return false;
+  }
+
+  // 查找同级节点中的函数声明或变量声明
+  let current_node = node;
+  while (current_node.parent) {
+    // 查找同级节点中的函数声明
+    if (current_node.parent.body && Array.isArray(current_node.parent.body)) {
+      for (let sibling of current_node.parent.body) {
+        // 检查函数声明
+        if (sibling.type === 'FunctionDeclaration' && sibling.id && sibling.id.name === node.name) {
+          return true;
+        }
+
+        // 检查变量声明中的函数表达式
+        if (sibling.type === 'VariableDeclaration' && sibling.declarations) {
+          for (let decl of sibling.declarations) {
+            if (decl.id && decl.id.type === 'Identifier' && decl.id.name === node.name) {
+              // 检查变量是否通过函数表达式初始化
+              if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    }
+    current_node = current_node.parent;
+  }
+
+  return false;
+}
+
+/**
+ * 判断节点是否在函数体内
+ * @param {Object} node - AST节点
+ * @returns {boolean} 是否在函数体内
+ */
+ConstName.prototype._isInFunctionBody = function (node) {
+  let current_node = node;
+  while (current_node.parent) {
+    // 检查是否在函数体、箭头函数体或方法体内
+    if (current_node.parent.type === 'BlockStatement' &&
+      (current_node.parent.parent &&
+        (current_node.parent.parent.type === 'FunctionDeclaration' ||
+          current_node.parent.parent.type === 'FunctionExpression' ||
+          current_node.parent.parent.type === 'ArrowFunctionExpression' ||
+          current_node.parent.parent.type === 'MethodDefinition'))) {
+      return true;
+    }
+
+    // 检查是否在箭头函数的表达式体内（没有大括号的情况）
+    if (current_node.parent.type === 'ArrowFunctionExpression') {
+      return true;
+    }
+
+    current_node = current_node.parent;
+  }
+
+  return false;
+}
+
+/**
+ * 判断属性是否在常量对象中
+ * @param {Object} node - 属性节点
+ * @returns {boolean} 是否在常量对象中
+ */
+ConstName.prototype._isInConstantObject = function (node) {
+  // 向上查找父节点，判断是否在常量声明中
+  let current_node = node;
+  while (current_node.parent) {
+    // 排除函数体内的对象字面量
+    if (this._isInFunctionBody(current_node)) {
+      return false;
+    }
+
+    // 检查是否为常量声明（const）中的对象字面量
+    if (current_node.parent.type === 'VariableDeclarator' &&
+      current_node.parent.parent &&
+      current_node.parent.parent.type === 'VariableDeclaration' &&
+      current_node.parent.parent.kind === 'const') {
+      return true;
+    }
+
+    // 检查是否为 Object.freeze() 调用中的对象字面量
+    if (current_node.parent.type === 'CallExpression' &&
+      current_node.parent.callee &&
+      current_node.parent.callee.type === 'MemberExpression' &&
+      current_node.parent.callee.object &&
+      current_node.parent.callee.object.name === 'Object' &&
+      current_node.parent.callee.property &&
+      current_node.parent.callee.property.name === 'freeze') {
+      return true;
+    }
+
+    // 检查是否为 module.exports 或 exports 赋值中的对象字面量
+    if (current_node.parent.type === 'AssignmentExpression' &&
+      current_node.parent.left &&
+      current_node.parent.left.type === 'MemberExpression') {
+      let left_object = current_node.parent.left.object;
+      let is_exports = false;
+
+      if (left_object.type === 'Identifier' && left_object.name === 'exports') {
+        is_exports = true;
+      } else if (left_object.type === 'MemberExpression' &&
+        left_object.object.type === 'Identifier' &&
+        left_object.object.name === 'module' &&
+        left_object.property.type === 'Identifier' &&
+        left_object.property.name === 'exports') {
+        is_exports = true;
+      }
+
+      if (is_exports) {
+        return true;
+      }
+    }
+
+    current_node = current_node.parent;
+  }
+
+  // 默认情况下，不在常量对象中
+  return false;
+}
+
+/**
+ * 赋值表达式节点检测函数（常量赋值）
+ * @param {Object} node - 赋值表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ConstName.prototype.AssignmentExpression = function (node) {
+  // 检测 exports 或 module.exports 赋值：exports.CONSTANT_NAME = value;
+  // 排除右边是对象字面量的情况，交由Property检测器处理
+  if (node.operator === '=' && node.left && node.left.type === 'MemberExpression' &&
+    node.right && node.right.type !== 'ObjectExpression') {
+    // 检查左边是否为 exports 或 module.exports
+    let left_object = node.left.object;
+    let is_exports = false;
+
+    if (left_object.type === 'Identifier' && left_object.name === 'exports') {
+      is_exports = true;
+    } else if (left_object.type === 'MemberExpression' &&
+      left_object.object.type === 'Identifier' &&
+      left_object.object.name === 'module' &&
+      left_object.property.type === 'Identifier' &&
+      left_object.property.name === 'exports') {
+      is_exports = true;
+    }
+
+    if (is_exports && node.left.property && node.left.property.type === 'Identifier') {
+      // 排除类实例（new表达式）
+      if (node.right && node.right.type === 'NewExpression') {
+        return;
+      }
+
+      // 排除类实例引用（标识符指向类实例）
+      if (node.right && node.right.type === 'Identifier' && this._isClassInstanceReference(node.right)) {
+        return;
+      }
+
+      // 排除函数引用（标识符指向函数）
+      if (node.right && node.right.type === 'Identifier' && this._isFunctionReference(node.right)) {
+        return;
+      }
+
+      // 判断右边值是否为常量，同时排除类定义的情况
+      if (this._isConstantValue(node.right) && !this._isClassDefinition(node.right)) {
+        let name = node.left.property.name;
+        let original_type = 'property-constant';
+        let error = this.check(node.left.property, name, original_type);
+        this.report(node.left.property, error, original_type);
+        return error;
+      }
+    }
+  }
+}
+
+/**
+ * 默认导出节点检测函数（常量导出）
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ConstName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的常量
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    // 先判断导出的标识符是否为常量
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'constant') {
+      let name = node.declaration.name;
+      let original_type = 'export-constant';
+      let error = this.check(node.declaration, name, original_type);
+      this.report(node.declaration, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 命名导出节点检测函数（常量导出）
+ * @param {Object} node - 命名导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ConstName.prototype.ExportNamedDeclaration = function (node) {
+  // 检测导出的常量声明（如 export const CONSTANT_NAME = value）
+  if (node.declaration && node.declaration.type === 'VariableDeclaration') {
+    for (let i = 0; i < node.declaration.declarations.length; i++) {
+      let declaration = node.declaration.declarations[i];
+      if (declaration.id && declaration.id.type === 'Identifier') {
+        let name = declaration.id.name;
+        let error = this.check(node, name, 'export-constant');
+        this.report(node, error, 'export-constant');
+        return error;
+      }
+    }
+  }
+
+  // 检测导出的常量引用
+  if (node.specifiers && node.specifiers.length > 0) {
+    for (let i = 0; i < node.specifiers.length; i++) {
+      let specifier = node.specifiers[i];
+
+      // 检测导出的标识符（避免重复检测）
+      // 优先检测 exported 属性，如果存在则使用它，否则使用 local 属性
+      let identifier_to_check = null;
+      let identifier_name = '';
+      
+      if (specifier.exported && specifier.exported.type === 'Identifier') {
+        identifier_to_check = specifier.exported;
+        identifier_name = specifier.exported.name;
+      } else if (specifier.local && specifier.local.type === 'Identifier') {
+        identifier_to_check = specifier.local;
+        identifier_name = specifier.local.name;
+      }
+      
+      // 只有当找到有效标识符时才进行检测
+      if (identifier_to_check) {
+        let original_type = this._getOriginalType(specifier, 'ExportSpecifier');
+
+        // 只有当导出的是常量时才检测
+        if (original_type === 'constant') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-constant');
+          this.report(identifier_to_check, error, 'export-constant');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  ConstName
+};