@lsby/eslint-plugin 0.0.27 → 0.0.29

package/dist/lib/rules/prefer-switch-for-literal-enum.d.ts

@@ -1,3 +1,3 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-declare const rule: TSESLint.RuleModule<'useSwitchForEnumLiteral', []>;
+declare const rule: TSESLint.RuleModule<'preferSwitch', []>;
 export default rule;

package/dist/lib/rules/prefer-switch-for-literal-enum.js

@@ -1,143 +1,249 @@
 "use strict";
-// 禁止对字面量枚举进行 if 判断并使用 else
-// 当判断字面量枚举时，应该使用 switch 来穷尽所有情况
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+// 禁止对字面量枚举进行 if-else 判断
+// 因为一旦字面量状态扩充, else 就会默默吃掉新增的状态
+// 当判断字面量枚举时, 应该使用 switch 来穷尽所有情况
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const rule = {
     meta: {
         type: 'suggestion',
-        docs: { description: '禁止对字面量枚举进行 if 判断并使用 else，应该使用 switch 来穷尽所有情况.' },
-        messages: { useSwitchForEnumLiteral: '检测到对字面量枚举的 if-else 判断，建议改用 switch 来穷尽所有情况.' },
+        docs: { description: '禁止对字面量枚举进行 if-else 判断，应使用 switch' },
+        messages: { preferSwitch: '对字面量联合类型应使用 switch 语句而不是 if-else，以确保穷尽所有分支' },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
-        const parserServices = context.parserServices;
-        const typeChecker = parserServices?.program?.getTypeChecker();
-        /**
-         * 检查类型是否是字面量联合类型（枚举）
-         * 返回 true 如果是纯字面量联合类型，false 否则
-         * 排除布尔值类型（true | false 是语言的基本类型，不属于枚举）
-         */
-        function isLiteralUnionType(type) {
-            if (!typeChecker)
-                return false;
-            // 如果是布尔类型或只包含布尔字面量，排除掉
-            if ((type.flags & ts.TypeFlags.Boolean) !== 0) {
-                return false;
-            }
-            // 检查是否是联合类型
-            if ((type.flags & ts.TypeFlags.Union) === 0) {
-                return false;
-            }
-            const union = type;
-            // 联合类型中必须至少有 2 个成员
-            if (union.types.length < 2) {
-                return false;
-            }
-            // 检查所有类型成员是否都是字面量类型（只接受字符串和数字字面量，排除布尔值）
-            for (const t of union.types) {
-                const isStringLiteral = (t.flags & ts.TypeFlags.StringLiteral) !== 0;
-                const isNumberLiteral = (t.flags & ts.TypeFlags.NumberLiteral) !== 0;
-                // 注意：不接受布尔字面量，布尔值是语言基本类型
-                if (!isStringLiteral && !isNumberLiteral) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        /**
-         * 获取被比较的变量的类型
-         */
-        function getComparisonVariableType(expr) {
-            if (!typeChecker || !parserServices?.esTreeNodeToTSNodeMap) {
-                return null;
-            }
-            try {
-                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(expr);
-                if (!tsNode)
-                    return null;
-                if (expr.type === 'Identifier') {
-                    const symbol = typeChecker.getSymbolAtLocation(tsNode);
-                    if (symbol && symbol.valueDeclaration) {
-                        return typeChecker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
-                    }
-                }
-                return typeChecker.getTypeAtLocation(tsNode);
-            }
-            catch {
-                return null;
-            }
-        }
-        /**
-         * 检查条件是否是简单的等于比较
-         */
-        function getEqualityOperands(node) {
-            if (node.type === 'BinaryExpression') {
-                const binExpr = node;
-                if (['===', '!==', '==', '!='].includes(binExpr.operator)) {
-                    return [binExpr.left, binExpr.right];
-                }
-            }
-            return null;
-        }
         return {
             IfStatement(node) {
-                // 仅在 if 有 else 分支时检查
-                if (node.alternate === null) {
-                    return;
-                }
-                // 检查是否是等于/不等于比较
-                const operands = getEqualityOperands(node.test);
-                if (!operands) {
+                // 只检查不是某个 else if 的 if 语句（即顶层的 if）
+                const parent = node.parent;
+                if (parent && parent.type === 'IfStatement' && parent.alternate === node) {
                     return;
                 }
-                const [left, right] = operands;
-                // 尝试从两边获取类型，判断是否是字面量枚举
-                const leftType = getComparisonVariableType(left);
-                const rightType = getComparisonVariableType(right);
-                if (leftType && isLiteralUnionType(leftType)) {
-                    context.report({ node: node.alternate, messageId: 'useSwitchForEnumLiteral' });
+                // 检查是否有最终的 else 分支
+                if (!hasFinalElseBranch(node))
                     return;
-                }
-                if (rightType && isLiteralUnionType(rightType)) {
-                    context.report({ node: node.alternate, messageId: 'useSwitchForEnumLiteral' });
+                // 检查是否是字面量对比（test 是 BinaryExpression === 或 == 比较）
+                if (node.test.type === 'BinaryExpression' && (node.test.operator === '===' || node.test.operator === '==')) {
+                    const { left, right } = node.test;
+                    // 使用 TypeScript 类型检查器检查类型
+                    const parserServices = context.parserServices;
+                    if (!parserServices || !parserServices.program)
+                        return;
+                    const typeChecker = parserServices.program.getTypeChecker();
+                    // 获取比较的主体（可能是左侧或右侧，且不是字面量）
+                    const comparedSubject = getComparedSubject(left, right, parserServices, typeChecker);
+                    if (!comparedSubject)
+                        return;
+                    const tsNode = comparedSubject;
+                    // 尝试获取主体的声明类型而不仅仅是值的类型
+                    let variableType = typeChecker.getTypeAtLocation(tsNode);
+                    // 如果是标识符，尝试获取其符号的类型
+                    if (typescript_1.default.isIdentifier(tsNode)) {
+                        const symbol = typeChecker.getSymbolAtLocation(tsNode);
+                        if (symbol) {
+                            const declarations = symbol.declarations;
+                            if (declarations && declarations.length > 0) {
+                                // 尝试从变量声明获取类型
+                                const declaration = declarations[0];
+                                if (typescript_1.default.isVariableDeclaration(declaration) && declaration.type) {
+                                    variableType = typeChecker.getTypeFromTypeNode(declaration.type);
+                                }
+                            }
+                        }
+                    }
+                    // 检查是否是字面量联合类型
+                    const literalTypeIds = getLiteralTypeIds(variableType);
+                    if (literalTypeIds.length === 0)
+                        return;
+                    // 检查 if-else 链是否混合使用了相等和其他比较操作符
+                    // 为了避免复杂性和误伤，混合使用的情况下放行
+                    if (hasMixedComparisonOperators(node))
+                        return;
+                    // 统计 if-else if 链中已经处理的字面量值（使用 Type.id 来区分）
+                    const handledTypeIds = new Set();
+                    collectHandledTypeIds(node, tsNode, typeChecker, parserServices, handledTypeIds);
+                    // 计算 else 分支实际处理的情况数
+                    const uncoveredCount = literalTypeIds.length - handledTypeIds.size;
+                    // 只有当 else 覆盖多于一种情况时才报错
+                    if (uncoveredCount > 1) {
+                        context.report({ node, messageId: 'preferSwitch' });
+                    }
                 }
             },
         };
     },
 };
+/**
+ * 检查 if-else 链是否有最终的 else 分支
+ */
+function hasFinalElseBranch(node) {
+    let current = node;
+    while (current.type === 'IfStatement') {
+        if (current.alternate === null)
+            return false;
+        if (current.alternate.type !== 'IfStatement')
+            return true;
+        current = current.alternate;
+    }
+    return false;
+}
+/**
+ * 检查 if-else if 链是否混合使用了相等操作符（=== 或 ==）和其他比较操作符（>, <, >=, <=, !=, !==）
+ * 如果混合使用，为了避免复杂的逻辑分析和误伤，返回 true（应该放行）
+ */
+function hasMixedComparisonOperators(node) {
+    let hasEqualityOperator = false;
+    let hasOtherOperator = false;
+    let current = node;
+    while (current) {
+        if (current.test.type === 'BinaryExpression') {
+            const operator = current.test.operator;
+            // 相等操作符
+            if (operator === '===' || operator === '==') {
+                hasEqualityOperator = true;
+            }
+            // 其他比较操作符
+            if (operator === '>' ||
+                operator === '<' ||
+                operator === '>=' ||
+                operator === '<=' ||
+                operator === '!=' ||
+                operator === '!==') {
+                hasOtherOperator = true;
+            }
+        }
+        // 如果发现了混合使用，立即返回
+        if (hasEqualityOperator && hasOtherOperator) {
+            return true;
+        }
+        // 移动到 else if
+        if (current.alternate && current.alternate.type === 'IfStatement') {
+            current = current.alternate;
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+/**
+ * 检查是否是字面量类型（字符串、数字或布尔字面量）
+ */
+function isLiteralType(type) {
+    return type.isStringLiteral() || type.isNumberLiteral() || !!(type.flags & typescript_1.default.TypeFlags.BooleanLiteral);
+}
+/**
+ * 从二元表达式的左右两侧提取被比较的"主体"（非字面量值的那一侧）
+ * 支持任意表达式：Identifier, MemberExpression, CallExpression, TSAsExpression 等
+ * 也支持常量引用（如 const X = 'a' as const，然后 if (y === X)）
+ * 返回 TypeScript AST 节点，如果两侧都是字面量或无法确定则返回 null
+ */
+function getComparedSubject(left, right, parserServices, typeChecker) {
+    const tsLeft = parserServices.esTreeNodeToTSNodeMap.get(left);
+    const tsRight = parserServices.esTreeNodeToTSNodeMap.get(right);
+    // 首先检查 AST 节点类型，优先识别直接的字面量
+    const isLeftAstLiteral = left.type === 'Literal';
+    const isRightAstLiteral = right.type === 'Literal';
+    // 如果一侧是 AST 字面量，另一侧不是，直接返回
+    if (isLeftAstLiteral && !isRightAstLiteral) {
+        return tsRight;
+    }
+    else if (!isLeftAstLiteral && isRightAstLiteral) {
+        return tsLeft;
+    }
+    // 如果都不是 AST 字面量，尝试用类型系统判断（支持 as const 常量）
+    if (!isLeftAstLiteral && !isRightAstLiteral) {
+        const leftType = typeChecker.getTypeAtLocation(tsLeft);
+        const rightType = typeChecker.getTypeAtLocation(tsRight);
+        const isLeftLiteralType = isLiteralType(leftType);
+        const isRightLiteralType = isLiteralType(rightType);
+        // 只有当一侧是字面量类型，另一侧不是时，才能继续
+        if (isLeftLiteralType && !isRightLiteralType) {
+            return tsRight;
+        }
+        else if (!isLeftLiteralType && isRightLiteralType) {
+            return tsLeft;
+        }
+    }
+    return null;
+}
+/**
+ * 比较两个 TypeScript AST 节点是否代表同一个主体
+ * 支持：
+ * - Identifier：变量名相同
+ * - MemberExpression：对象和属性都相同
+ * - CallExpression：函数和参数都相同
+ * - TSAsExpression：忽略类型断言，比较内层表达式
+ * 等等
+ */
+function isSameSubject(node1, node2, typeChecker) {
+    // 简单的情况：节点文本相同
+    if (node1.getText() === node2.getText()) {
+        return true;
+    }
+    // 如果两个节点的符号相同，认为它们代表同一个主体
+    if (typescript_1.default.isIdentifier(node1) && typescript_1.default.isIdentifier(node2)) {
+        const symbol1 = typeChecker.getSymbolAtLocation(node1);
+        const symbol2 = typeChecker.getSymbolAtLocation(node2);
+        if (symbol1 && symbol2 && symbol1 === symbol2) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 获取字面量联合类型的所有 Type.id
+ */
+function getLiteralTypeIds(type) {
+    const typeIds = [];
+    if (type.isUnion()) {
+        type.types.forEach((memberType) => {
+            if (isLiteralType(memberType)) {
+                typeIds.push(memberType.id);
+            }
+        });
+    }
+    else {
+        if (isLiteralType(type)) {
+            typeIds.push(type.id);
+        }
+    }
+    return typeIds;
+}
+/**
+ * 递归收集 if-else if 链中已经处理的字面量值（使用 Type.id 来区分）
+ */
+function collectHandledTypeIds(node, comparedSubject, typeChecker, parserServices, handledTypeIds) {
+    // 检查当前 if 的条件
+    if (node.test.type === 'BinaryExpression' && (node.test.operator === '===' || node.test.operator === '==')) {
+        const { left, right } = node.test;
+        // 判断哪一侧是比较的主体，哪一侧是值
+        let valueNode = null;
+        const tsLeft = parserServices.esTreeNodeToTSNodeMap.get(left);
+        const tsRight = parserServices.esTreeNodeToTSNodeMap.get(right);
+        if (isSameSubject(tsLeft, comparedSubject, typeChecker)) {
+            valueNode = right;
+        }
+        else if (isSameSubject(tsRight, comparedSubject, typeChecker)) {
+            valueNode = left;
+        }
+        if (valueNode) {
+            // 获取值表达式的 TypeScript 类型
+            const tsValueNode = parserServices.esTreeNodeToTSNodeMap.get(valueNode);
+            const valueType = typeChecker.getTypeAtLocation(tsValueNode);
+            // 如果是字面量类型，添加其 id
+            if (isLiteralType(valueType)) {
+                handledTypeIds.add(valueType.id);
+            }
+        }
+    }
+    // 递归检查 else if
+    if (node.alternate && node.alternate.type === 'IfStatement') {
+        collectHandledTypeIds(node.alternate, comparedSubject, typeChecker, parserServices, handledTypeIds);
+    }
+}
 exports.default = rule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsby/eslint-plugin",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [