mm_eslint 1.4.5 → 1.4.7

package/lib/detector/name.js

@@ -0,0 +1,626 @@
+const { Config } = require('../config.js');
+const { Validator } = require('../validator.js');
+const { Corrector } = require('../corrector.js');
+const { Tip } = require('../tip.js');
+const { Fix } = require('../fix.js');
+
+/**
+ * 函数名检测器类
+ * 负责检测函数名是否符合命名规范
+ */
+class Name {
+  constructor(context, config) {
+    this.config = new Config();
+    Object.assign(this.config, config);
+    this.validator = new Validator(this.config);
+    this.corrector = new Corrector(this.config);
+    this.tip = new Tip(this.config);
+    this.fix = new Fix(this.config);
+    this.context = context;
+  }
+}
+
+/**
+ * 检查函数名是否符合规范
+ * @param {Object} node - 节点对象
+ * @param {string} name - 节点名称
+ * @param {string} original_type - 源类型
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+Name.prototype.check = function (node, name, original_type) {
+  let error = this.validator.validate(name, original_type);
+  if (error) {
+    let suggestion = this.corrector.getSuggestion(error);
+    if (suggestion) {
+      error.suggestion = suggestion;
+    }
+    error.node = node;
+    error.message = this.tip.getFullMessage(error);
+  }
+  return error;
+}
+
+/**
+ * 负责报告不符合命名规范的错误，并提供修复建议
+ * @param {Object} node - 节点对象
+ * @param {Object} error - 检测错误对象
+ * @param {string} type - 错误类型
+ */
+Name.prototype.report = function (node, error, type) {
+  if (!error) {
+    return;
+  }
+
+  // 设置错误类型信息
+  error.original_type = type;
+
+  // 如果有修复建议，创建修复函数
+  if (error.suggestion) {
+    error.fix_suggestion = error.suggestion;
+
+    // 使用新的模块化修复系统
+    error.fix = this.fix.createFixFunction(this.context, node, error);
+  }
+
+  // 设置错误位置信息
+  error.node = node;
+
+  // 对于变量声明，精确定位到标识符位置
+  if (node.type === 'VariableDeclaration' && node.declarations && node.declarations.length > 0) {
+    const declaration = node.declarations[0];
+    if (declaration.id && declaration.id.type === 'Identifier') {
+      // 使用标识符的位置作为错误位置
+      error.loc = declaration.id.loc;
+    }
+  } else if (node.type === 'Identifier') {
+    // 直接使用标识符的位置
+    error.loc = node.loc;
+  } else {
+    // 默认使用节点的位置
+    error.loc = node.loc;
+  }
+
+  this.context.report(error);
+}
+
+/**
+ * 根据赋值语句右边的标识符判断其原始类型
+ * @param {Object} node - 节点对象
+ * @param {string} node_type - 节点类型
+ * @returns {string} - 原始类型
+ */
+Name.prototype._getOriginalType = function (node, node_type) {
+  let right_identifier;
+
+  // 处理 VariableDeclaration 节点
+  if (node_type === 'VariableDeclaration' && node.init && node.init.type === 'Identifier') {
+    right_identifier = node.init;
+  }
+  // 处理 Property 节点
+  else if (node_type === 'Property' && node.value && node.value.type === 'Identifier') {
+    right_identifier = node.value;
+  }
+  // 处理 PropertyDefinition 节点（类属性）
+  else if (node_type === 'PropertyDefinition' && node.value && node.value.type === 'Identifier') {
+    right_identifier = node.value;
+  }
+  // 处理 AssignmentExpression 节点
+  else if (node_type === 'AssignmentExpression' && node.right && node.right.type === 'Identifier') {
+    right_identifier = node.right;
+  }
+  // 处理 ExportSpecifier 节点
+  else if (node_type === 'ExportSpecifier') {
+    // 优先检查 exported 属性（实际导出的标识符）
+    if (node.exported && node.exported.type === 'Identifier') {
+      right_identifier = node.exported;
+    }
+    // 如果没有 exported，检查 local 属性
+    else if (node.local && node.local.type === 'Identifier') {
+      right_identifier = node.local;
+    }
+  }
+  // 处理 ExportDefaultDeclaration 节点
+  else if (node_type === 'ExportDefaultDeclaration') {
+    // 处理默认导出（如 export default name）
+    right_identifier = node
+  }
+  else {
+    return 'variable';
+  }
+
+  if (!right_identifier) {
+    return 'variable';
+  }
+
+  let right_name = right_identifier.name;
+
+  // 优化类型识别逻辑：根据标识符的实际定义准确判断类型
+
+  // 1. 首先检查是否为类（最精确的判断）
+  if (this._isClassInScope(right_name, node)) {
+    return 'class';
+  }
+
+  // 2. 检查是否为类实例（需要精确判断）
+  if (this._isClassInstanceInScope(right_name, node)) {
+    return 'class-instance';
+  }
+
+  // 3. 检查是否为函数（需要精确判断）
+  if (this._isFunctionInScope(right_name, node)) {
+    return 'function';
+  }
+
+  // 4. 检查是否为常量
+  if (this._isConstantInScope(right_name, node)) {
+    return 'constant';
+  }
+
+  // 5. 检查是否为对象
+  if (this._isObjectInScope(right_name, node)) {
+    return 'object';
+  }
+
+  // 6. 检查是否为变量
+  if (this._isVariableInScope(right_name, node)) {
+    return 'variable';
+  }
+
+  // 默认返回未知类型
+  return 'unknown';
+}
+
+/**
+ * 检查标识符是否在作用域内定义为类
+ * @param {string} name - 标识符名称
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否是类
+ */
+Name.prototype._isClassInScope = function (name, node) {
+  // 获取AST根节点
+  var program_node = this._getProgramNode(node);
+  if (!program_node) {
+    return false;
+  }
+
+  // 遍历所有同级节点
+  for (var i = 0; i < program_node.body.length; i++) {
+    var sibling_node = program_node.body[i];
+
+    // 检查类声明
+    if (sibling_node.type === 'ClassDeclaration' && sibling_node.id && sibling_node.id.name === name) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查标识符是否在作用域内定义为函数
+ * @param {string} name - 标识符名称
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否是函数
+ */
+Name.prototype._isFunctionInScope = function (name, node) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(node);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历同级节点查找函数声明
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 查找函数声明
+    if (sibling_node.type === 'FunctionDeclaration') {
+      if (sibling_node.id && sibling_node.id.type === 'Identifier' && sibling_node.id.name === name) {
+        return true;
+      }
+    }
+
+    // 查找变量声明中的函数表达式
+    if (sibling_node.type === 'VariableDeclaration') {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+          // 检查是否为函数表达式
+          if (decl.init && (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression')) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查标识符是否在作用域内定义为对象
+ * @param {string} name - 标识符名称
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否是对象
+ */
+Name.prototype._isObjectInScope = function (name, node) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(node);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历同级节点查找对象声明
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 查找变量声明中的对象
+    if (sibling_node.type === 'VariableDeclaration') {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+          // 检查是否为对象表达式
+          if (decl.init && decl.init.type === 'ObjectExpression') {
+            return true;
+          }
+          // 检查是否为数组表达式（也视为对象的一种）
+          if (decl.init && decl.init.type === 'ArrayExpression') {
+            return true;
+          }
+          // 检查是否为函数调用返回的对象
+          if (decl.init && decl.init.type === 'CallExpression') {
+            return this._isFunctionReturningObject(decl.init);
+          }
+        }
+      }
+    }
+
+    // 查找赋值表达式中的对象
+    if (sibling_node.type === 'ExpressionStatement' && sibling_node.expression && sibling_node.expression.type === 'AssignmentExpression') {
+      let expr = sibling_node.expression;
+      if (expr.left && expr.left.type === 'Identifier' && expr.left.name === name) {
+        // 检查右边是否为对象表达式
+        if (expr.right && expr.right.type === 'ObjectExpression') {
+          return true;
+        }
+        // 检查右边是否为数组表达式
+        if (expr.right && expr.right.type === 'ArrayExpression') {
+          return true;
+        }
+        // 检查右边是否为函数调用返回的对象
+        if (expr.right && expr.right.type === 'CallExpression') {
+          return this._isFunctionReturningObject(expr.right);
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查标识符是否在作用域内定义为常量
+ * @param {string} name - 标识符名称
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否是常量
+ */
+Name.prototype._isConstantInScope = function (name, node) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(node);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历同级节点查找常量声明
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 查找常量声明（const）
+    if (sibling_node.type === 'VariableDeclaration' && sibling_node.kind === 'const') {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查标识符是否在作用域内定义为变量
+ * @param {string} name - 标识符名称
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否是变量
+ */
+Name.prototype._isVariableInScope = function (name, node) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(node);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历同级节点查找变量声明
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 查找变量声明（let 和 var）
+    if (sibling_node.type === 'VariableDeclaration' && (sibling_node.kind === 'let' || sibling_node.kind === 'var')) {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查标识符是否在作用域内定义为类实例
+ * @param {string} name - 标识符名称
+ * @param {Object} node - 当前节点
+ * @returns {boolean} - 是否是类实例
+ */
+Name.prototype._isClassInstanceInScope = function (name, node) {
+  if (!name || !node) {
+    return false;
+  }
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(node);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历同级节点查找类实例声明
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 查找变量声明（let 和 var）
+    if (sibling_node.type === 'VariableDeclaration' && (sibling_node.kind === 'let' || sibling_node.kind === 'var' || sibling_node.kind === 'const')) {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+
+        // 检查右边是否为 new 表达式
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === name && decl.init && decl.init.type === 'NewExpression') {
+          return true;
+        }
+      }
+    }
+
+    // 查找属性声明
+    if (sibling_node.type === 'ExpressionStatement' && sibling_node.expression && sibling_node.expression.type === 'AssignmentExpression') {
+      let expr = sibling_node.expression;
+      // 检查左边是否为标识符，右边是否为 new 表达式
+      if (expr.left && expr.left.type === 'Identifier' && expr.left.name === name && expr.right && expr.right.type === 'NewExpression') {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查函数调用是否返回对象
+ * @param {Object} call_expr - 函数调用表达式节点
+ * @returns {boolean} - 是否返回对象
+ */
+Name.prototype._isFunctionReturningObject = function (call_expr) {
+  if (!call_expr || call_expr.type !== 'CallExpression') {
+    return false;
+  }
+
+  // 获取被调用的函数标识符
+  let callee = call_expr.callee;
+  if (!callee || callee.type !== 'Identifier') {
+    return false;
+  }
+
+  let func_name = callee.name;
+
+  // 获取AST根节点
+  let program_node = this._getProgramNode(call_expr);
+  if (!program_node || !program_node.body) {
+    return false;
+  }
+
+  // 遍历查找函数定义
+  for (let i = 0; i < program_node.body.length; i++) {
+    let sibling_node = program_node.body[i];
+
+    // 查找函数声明
+    if (sibling_node.type === 'FunctionDeclaration' && sibling_node.id && sibling_node.id.name === func_name) {
+      // 检查函数体是否返回对象
+      return this._doesFunctionReturnObject(sibling_node);
+    }
+
+    // 查找变量声明中的函数表达式
+    if (sibling_node.type === 'VariableDeclaration') {
+      for (let j = 0; j < sibling_node.declarations.length; j++) {
+        let decl = sibling_node.declarations[j];
+        if (decl.id && decl.id.type === 'Identifier' && decl.id.name === func_name && decl.init) {
+          // 检查是否为函数表达式
+          if (decl.init.type === 'FunctionExpression' || decl.init.type === 'ArrowFunctionExpression') {
+            return this._doesFunctionReturnObject(decl.init);
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 检查函数是否返回对象
+ * @param {Object} func_node - 函数节点
+ * @returns {boolean} - 是否返回对象
+ */
+Name.prototype._doesFunctionReturnObject = function (func_node) {
+  if (!func_node || !func_node.body) {
+    return false;
+  }
+
+  // 检查函数体中的返回语句
+  let body = func_node.body;
+
+  // 如果是块语句，遍历其中的语句
+  if (body.type === 'BlockStatement' && body.body) {
+    for (let i = 0; i < body.body.length; i++) {
+      let stmt = body.body[i];
+      if (stmt.type === 'ReturnStatement' && stmt.argument) {
+        // 检查返回值是否为对象表达式
+        if (stmt.argument.type === 'ObjectExpression') {
+          return true;
+        }
+        // 检查返回值是否为数组表达式
+        if (stmt.argument.type === 'ArrayExpression') {
+          return true;
+        }
+        // 检查返回值是否为函数调用（可能返回对象）
+        if (stmt.argument.type === 'CallExpression') {
+          return true; // 保守估计，假设函数调用可能返回对象
+        }
+      }
+    }
+  }
+
+  // 对于箭头函数，如果是表达式体，直接检查返回值
+  if (func_node.type === 'ArrowFunctionExpression' && body.type !== 'BlockStatement') {
+    // 检查表达式体是否为对象表达式
+    if (body.type === 'ObjectExpression') {
+      return true;
+    }
+    // 检查表达式体是否为数组表达式
+    if (body.type === 'ArrayExpression') {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 获取AST根节点
+ * @param {Object} node - 当前节点
+ * @returns {Object} - 根节点
+ */
+Name.prototype._getProgramNode = function (node) {
+  while (node && node.parent) {
+    node = node.parent;
+  }
+  return node;
+}
+
+/**
+ * 判断属性是否在常量对象中
+ * @param {Object} node - 属性节点
+ * @returns {boolean} 是否在常量对象中
+ */
+Name.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;
+    }
+
+    // 检查是否为 Object.seal() 调用中的对象字面量
+    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 === 'seal') {
+      return true;
+    }
+
+    // 检查是否为 Object.preventExtensions() 调用中的对象字面量
+    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 === 'preventExtensions') {
+      return true;
+    }
+
+    current_node = current_node.parent;
+  }
+
+  return false;
+}
+
+/**
+ * 判断节点是否在函数体内
+ * @param {Object} node - 节点
+ * @returns {boolean} 是否在函数体内
+ */
+Name.prototype._isInFunctionBody = function (node) {
+  let current_node = node;
+  while (current_node.parent) {
+    // 检查是否在函数声明或函数表达式中
+    if (current_node.parent.type === 'FunctionDeclaration' ||
+      current_node.parent.type === 'FunctionExpression' ||
+      current_node.parent.type === 'ArrowFunctionExpression') {
+      return true;
+    }
+
+    // 检查是否在箭头函数的表达式体内（没有大括号的情况）
+    if (current_node.parent.type === 'ArrowFunctionExpression') {
+      return true;
+    }
+
+    current_node = current_node.parent;
+  }
+
+  return false;
+}
+
+module.exports = {
+  Name
+};