@cdklabs/eslint-plugin 1.3.6 → 1.4.1

package/lib/index.d.ts

@@ -10,4 +10,5 @@ export declare const rules: {
     'no-throw-default-error': any;
     'promiseall-no-unbounded-parallelism': any;
     'no-this-in-static': any;
+    'no-evaluating-typeguard': any;
 };

package/lib/index.js

@@ -14,5 +14,6 @@ exports.rules = {
     'no-throw-default-error': require('./rules/no-throw-default-error'),
     'promiseall-no-unbounded-parallelism': require('./rules/promiseall-no-unbounded-parallelism'),
     'no-this-in-static': require('./rules/no-this-in-static'),
+    'no-evaluating-typeguard': require('./rules/no-evaluating-typeguard'),
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBEQUEwRDs7O0FBRTdDLFFBQUEsSUFBSSxHQUFHO0lBQ2xCLElBQUksRUFBRSxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxJQUFJO0lBQ3JDLE9BQU8sRUFBRSxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxPQUFPO0NBQzVDLENBQUM7QUFFVyxRQUFBLEtBQUssR0FBRztJQUNuQixtQkFBbUIsRUFBRSxPQUFPLENBQUMsMkJBQTJCLENBQUM7SUFDekQscUJBQXFCLEVBQUUsT0FBTyxDQUFDLDZCQUE2QixDQUFDO0lBQzdELHNCQUFzQixFQUFFLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQztJQUMvRCxpQkFBaUIsRUFBRSxPQUFPLENBQUMseUJBQXlCLENBQUM7SUFDckQsd0JBQXdCLEVBQUUsT0FBTyxDQUFDLGdDQUFnQyxDQUFDO0lBQ25FLHFDQUFxQyxFQUFFLE9BQU8sQ0FBQyw2Q0FBNkMsQ0FBQztJQUM3RixtQkFBbUIsRUFBRSxPQUFPLENBQUMsMkJBQTJCLENBQUM7Q0FDMUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1yZXF1aXJlLWltcG9ydHMgKi9cblxuZXhwb3J0IGNvbnN0IG1ldGEgPSB7XG4gIG5hbWU6IHJlcXVpcmUoJy4uL3BhY2thZ2UuanNvbicpLm5hbWUsXG4gIHZlcnNpb246IHJlcXVpcmUoJy4uL3BhY2thZ2UuanNvbicpLnZlcnNpb24sXG59O1xuXG5leHBvcnQgY29uc3QgcnVsZXMgPSB7XG4gICduby1jb3JlLWNvbnN0cnVjdCc6IHJlcXVpcmUoJy4vcnVsZXMvbm8tY29yZS1jb25zdHJ1Y3QnKSxcbiAgJ2ludmFsaWQtY2ZuLWltcG9ydHMnOiByZXF1aXJlKCcuL3J1bGVzL2ludmFsaWQtY2ZuLWltcG9ydHMnKSxcbiAgJ25vLWxpdGVyYWwtcGFydGl0aW9uJzogcmVxdWlyZSgnLi9ydWxlcy9uby1saXRlcmFsLXBhcnRpdGlvbicpLFxuICAnbm8taW52YWxpZC1wYXRoJzogcmVxdWlyZSgnLi9ydWxlcy9uby1pbnZhbGlkLXBhdGgnKSxcbiAgJ25vLXRocm93LWRlZmF1bHQtZXJyb3InOiByZXF1aXJlKCcuL3J1bGVzL25vLXRocm93LWRlZmF1bHQtZXJyb3InKSxcbiAgJ3Byb21pc2VhbGwtbm8tdW5ib3VuZGVkLXBhcmFsbGVsaXNtJzogcmVxdWlyZSgnLi9ydWxlcy9wcm9taXNlYWxsLW5vLXVuYm91bmRlZC1wYXJhbGxlbGlzbScpLFxuICAnbm8tdGhpcy1pbi1zdGF0aWMnOiByZXF1aXJlKCcuL3J1bGVzL25vLXRoaXMtaW4tc3RhdGljJyksXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBEQUEwRDs7O0FBRTdDLFFBQUEsSUFBSSxHQUFHO0lBQ2xCLElBQUksRUFBRSxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxJQUFJO0lBQ3JDLE9BQU8sRUFBRSxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxPQUFPO0NBQzVDLENBQUM7QUFFVyxRQUFBLEtBQUssR0FBRztJQUNuQixtQkFBbUIsRUFBRSxPQUFPLENBQUMsMkJBQTJCLENBQUM7SUFDekQscUJBQXFCLEVBQUUsT0FBTyxDQUFDLDZCQUE2QixDQUFDO0lBQzdELHNCQUFzQixFQUFFLE9BQU8sQ0FBQyw4QkFBOEIsQ0FBQztJQUMvRCxpQkFBaUIsRUFBRSxPQUFPLENBQUMseUJBQXlCLENBQUM7SUFDckQsd0JBQXdCLEVBQUUsT0FBTyxDQUFDLGdDQUFnQyxDQUFDO0lBQ25FLHFDQUFxQyxFQUFFLE9BQU8sQ0FBQyw2Q0FBNkMsQ0FBQztJQUM3RixtQkFBbUIsRUFBRSxPQUFPLENBQUMsMkJBQTJCLENBQUM7SUFDekQseUJBQXlCLEVBQUUsT0FBTyxDQUFDLGlDQUFpQyxDQUFDO0NBQ3RFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzICovXG5cbmV4cG9ydCBjb25zdCBtZXRhID0ge1xuICBuYW1lOiByZXF1aXJlKCcuLi9wYWNrYWdlLmpzb24nKS5uYW1lLFxuICB2ZXJzaW9uOiByZXF1aXJlKCcuLi9wYWNrYWdlLmpzb24nKS52ZXJzaW9uLFxufTtcblxuZXhwb3J0IGNvbnN0IHJ1bGVzID0ge1xuICAnbm8tY29yZS1jb25zdHJ1Y3QnOiByZXF1aXJlKCcuL3J1bGVzL25vLWNvcmUtY29uc3RydWN0JyksXG4gICdpbnZhbGlkLWNmbi1pbXBvcnRzJzogcmVxdWlyZSgnLi9ydWxlcy9pbnZhbGlkLWNmbi1pbXBvcnRzJyksXG4gICduby1saXRlcmFsLXBhcnRpdGlvbic6IHJlcXVpcmUoJy4vcnVsZXMvbm8tbGl0ZXJhbC1wYXJ0aXRpb24nKSxcbiAgJ25vLWludmFsaWQtcGF0aCc6IHJlcXVpcmUoJy4vcnVsZXMvbm8taW52YWxpZC1wYXRoJyksXG4gICduby10aHJvdy1kZWZhdWx0LWVycm9yJzogcmVxdWlyZSgnLi9ydWxlcy9uby10aHJvdy1kZWZhdWx0LWVycm9yJyksXG4gICdwcm9taXNlYWxsLW5vLXVuYm91bmRlZC1wYXJhbGxlbGlzbSc6IHJlcXVpcmUoJy4vcnVsZXMvcHJvbWlzZWFsbC1uby11bmJvdW5kZWQtcGFyYWxsZWxpc20nKSxcbiAgJ25vLXRoaXMtaW4tc3RhdGljJzogcmVxdWlyZSgnLi9ydWxlcy9uby10aGlzLWluLXN0YXRpYycpLFxuICAnbm8tZXZhbHVhdGluZy10eXBlZ3VhcmQnOiByZXF1aXJlKCcuL3J1bGVzL25vLWV2YWx1YXRpbmctdHlwZWd1YXJkJyksXG59O1xuIl19

package/lib/rules/no-evaluating-typeguard.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+export declare const meta: Rule.RuleMetaData;
+export declare const defaultOptions: {};
+export declare function create(context: Rule.RuleContext): Rule.RuleListener;

package/lib/rules/no-evaluating-typeguard.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = exports.meta = void 0;
+exports.create = create;
+const utils_1 = require("@typescript-eslint/utils");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const typescript_1 = require("typescript");
+exports.meta = {
+    messages: {
+        avoidAccess: "{{ memberAccess }}: this will evaluate '{{ prop }}', which might throw if it's a getter. Prefer using `'{{ prop }}' in {{ obj }}` (don't forget to check for object-ness of {{ obj }} if necessary!)",
+    },
+};
+exports.defaultOptions = {};
+function create(context) {
+    const services = (0, eslint_utils_1.getParserServices)(context);
+    const functionStack = [];
+    //  const classDeclarations: Map<string, ClassDeclaration> = new Map();
+    /**
+     * Whether this function is a type predicate
+     *
+     * This is a short and sweet way to determine whether this is a function we should be checking.
+     *
+     * ```
+     * function isSomething(x: unknown): x is Something { ... }
+     * ```
+     */
+    function isUserDefinedTypeGuard(node) {
+        if (node.params.length !== 1 || node.params[0].type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return false;
+        }
+        return node.returnType?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate;
+    }
+    /**
+     * Whether this looks like a type coercion function
+     *
+     * There are a lot more heuristics involved here to determine whether this is actually
+     * a function that does a run-time type check. It could look like this for a number of reasons.
+     *
+     * ```
+     * function toSomething(x: SomeType): SomeSubType { ... }
+     * ```
+     */
+    function isTypeCoercionFunction(node) {
+        const typeChecker = services.program.getTypeChecker();
+        const functionType = services.getTypeAtLocation(node);
+        const callSignature = functionType.getCallSignatures()[0];
+        if (!callSignature) {
+            // Constructors, getters and setters don't have a call signature
+            return false;
+        }
+        const firstParameter = callSignature.getParameters()[0];
+        if (!firstParameter) {
+            // Couldn't resolve first parameter for some reason. This can happen if the argument is 'this'
+            return false;
+        }
+        const argumentType = typeChecker.getTypeOfSymbol(firstParameter);
+        const returnType = callSignature.getReturnType();
+        // If the output type is void this is not a type coercion
+        // eslint-disable-next-line no-bitwise
+        if ((returnType.getFlags() & typescript_1.TypeFlags.VoidLike) !== 0) {
+            return false;
+        }
+        // If the output type doesn't have a symbol, it's an anonymous type (`return { x: 3, y: 42 };`)
+        // Which is most likely not a coercion function.
+        if (returnType.getSymbol() == null) {
+            return false;
+        }
+        // Object methods are never type testing functions (static class methods might be)
+        if (node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition && !node.parent.static) {
+            return false;
+        }
+        // If the return type is assignable to the input type, then this looks like
+        // a downcast which probably means it's a type coercion function.
+        return (typeChecker.isTypeAssignableTo(returnType, argumentType)
+            && !typeChecker.isTypeAssignableTo(argumentType, returnType));
+    }
+    function maybeInteresting(node) {
+        if (node.params.length !== 1 || node.params[0].type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return undefined;
+        }
+        if (isUserDefinedTypeGuard(node) || isTypeCoercionFunction(node)) {
+            return {
+                argumentName: node.params[0].name,
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Enter a function and see if it's interesting
+     */
+    function enterFunction(node) {
+        functionStack.push(maybeInteresting(node));
+    }
+    function exitFunction() {
+        functionStack.pop();
+    }
+    function currentInteresting() {
+        return functionStack.length > 0 ? functionStack[functionStack.length - 1] : undefined;
+    }
+    function onlyInInterestingFunction(fn) {
+        return ((...args) => {
+            if (currentInteresting()) {
+                return fn(...args);
+            }
+            return undefined;
+        });
+    }
+    /**
+     * For member expressions in interesting functions
+     *
+     * - If their LHS refers to the only function argument; AND
+     *   - If their parent is a `typeof` node; OR
+     *   - The member expression is part of a boolean expression; OR
+     *   - The member expression is in a bang-bang operator (!!); OR
+     *   - The expression is by itself in an `if` or `return` or `?:` ternary
+     *
+     * Then that is a potential problem because it will evaluate a member
+     * that we potentially only wanted to test for presence.
+     */
+    function memberExpression(node) {
+        const current = currentInteresting();
+        // Only property access on the primary argument
+        if ((node.object.type !== utils_1.AST_NODE_TYPES.Identifier) || node.object.name !== current.argumentName) {
+            return;
+        }
+        let dangerous = false;
+        if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression && node.parent.operator === 'typeof') {
+            dangerous = true;
+        }
+        if (node.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression
+            && node.parent.operator === '!'
+            && node.parent.parent.type === utils_1.AST_NODE_TYPES.UnaryExpression
+            && node.parent.parent.operator === '!') {
+            dangerous = true;
+        }
+        if (node.parent.type === utils_1.AST_NODE_TYPES.LogicalExpression && ['&&', '||'].includes(node.parent.operator)) {
+            dangerous = true;
+        }
+        if ([utils_1.AST_NODE_TYPES.ReturnStatement, utils_1.AST_NODE_TYPES.IfStatement, utils_1.AST_NODE_TYPES.ConditionalExpression].includes(node.parent.type)) {
+            dangerous = true;
+        }
+        if (dangerous) {
+            const eslintNode = node;
+            context.report({
+                node: eslintNode,
+                messageId: 'avoidAccess',
+                loc: eslintNode.loc ?? { line: 0, column: 0 },
+                data: {
+                    memberAccess: context.sourceCode.getText(eslintNode),
+                    obj: current.argumentName,
+                    prop: node.property.name,
+                },
+            });
+        }
+    }
+    return {
+        'FunctionDeclaration': enterFunction,
+        'FunctionExpression': enterFunction,
+        'FunctionDeclaration:exit': exitFunction,
+        'FunctionExpression:exit': exitFunction,
+        'MemberExpression': onlyInInterestingFunction(memberExpression),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-evaluating-typeguard.js","sourceRoot":"","sources":["../../src/rules/no-evaluating-typeguard.ts"],"names":[],"mappings":"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","sourcesContent":["import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';\nimport { getParserServices } from '@typescript-eslint/utils/eslint-utils';\nimport { Rule } from 'eslint';\nimport type { MemberExpression } from 'estree';\nimport { TypeFlags } from 'typescript';\nimport NodeParentExtension = Rule.NodeParentExtension;\n\nexport const meta: Rule.RuleMetaData = {\n  messages: {\n    avoidAccess: \"{{ memberAccess }}: this will evaluate '{{ prop }}', which might throw if it's a getter. Prefer using `'{{ prop }}' in {{ obj }}` (don't forget to check for object-ness of {{ obj }} if necessary!)\",\n  },\n};\n\nexport const defaultOptions = {};\n\n\ninterface InterestingFunction {\n  readonly argumentName: string;\n}\n\nexport function create(context: Rule.RuleContext): Rule.RuleListener {\n  const services = getParserServices(context as any);\n\n  const functionStack: Array<InterestingFunction | undefined> = [];\n  //  const classDeclarations: Map<string, ClassDeclaration> = new Map();\n\n  /**\n   * Whether this function is a type predicate\n   *\n   * This is a short and sweet way to determine whether this is a function we should be checking.\n   *\n   * ```\n   * function isSomething(x: unknown): x is Something { ... }\n   * ```\n   */\n  function isUserDefinedTypeGuard(node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) {\n    if (node.params.length !== 1 || node.params[0].type !== AST_NODE_TYPES.Identifier) { return false; }\n    return node.returnType?.typeAnnotation.type === AST_NODE_TYPES.TSTypePredicate;\n  }\n\n  /**\n   * Whether this looks like a type coercion function\n   *\n   * There are a lot more heuristics involved here to determine whether this is actually\n   * a function that does a run-time type check. It could look like this for a number of reasons.\n   *\n   * ```\n   * function toSomething(x: SomeType): SomeSubType { ... }\n   * ```\n   */\n  function isTypeCoercionFunction(node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) {\n    const typeChecker = services.program.getTypeChecker();\n\n    const functionType = services.getTypeAtLocation(node);\n    const callSignature = functionType.getCallSignatures()[0];\n    if (!callSignature) {\n      // Constructors, getters and setters don't have a call signature\n      return false;\n    }\n\n    const firstParameter = callSignature.getParameters()[0];\n    if (!firstParameter) {\n      // Couldn't resolve first parameter for some reason. This can happen if the argument is 'this'\n      return false;\n    }\n\n    const argumentType = typeChecker.getTypeOfSymbol(firstParameter);\n    const returnType = callSignature.getReturnType();\n\n    // If the output type is void this is not a type coercion\n    // eslint-disable-next-line no-bitwise\n    if ((returnType.getFlags() & TypeFlags.VoidLike) !== 0) {\n      return false;\n    }\n\n    // If the output type doesn't have a symbol, it's an anonymous type (`return { x: 3, y: 42 };`)\n    // Which is most likely not a coercion function.\n    if (returnType.getSymbol() == null) {\n      return false;\n    }\n\n    // Object methods are never type testing functions (static class methods might be)\n    if (node.parent.type === AST_NODE_TYPES.MethodDefinition && !node.parent.static) {\n      return false;\n    }\n\n\n    // If the return type is assignable to the input type, then this looks like\n    // a downcast which probably means it's a type coercion function.\n    return (typeChecker.isTypeAssignableTo(returnType, argumentType)\n      && !typeChecker.isTypeAssignableTo(argumentType, returnType));\n  }\n\n  function maybeInteresting(node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression): InterestingFunction | undefined {\n    if (node.params.length !== 1 || node.params[0].type !== AST_NODE_TYPES.Identifier) { return undefined; }\n    if (isUserDefinedTypeGuard(node) || isTypeCoercionFunction(node)) {\n      return {\n        argumentName: (node.params[0] as TSESTree.Identifier).name,\n      };\n    }\n    return undefined;\n  }\n\n  /**\n   * Enter a function and see if it's interesting\n   */\n  function enterFunction(node: (TSESTree.FunctionDeclaration | TSESTree.FunctionExpression) & NodeParentExtension) {\n    functionStack.push(maybeInteresting(node));\n  }\n\n  function exitFunction() {\n    functionStack.pop();\n  }\n\n  function currentInteresting(): InterestingFunction | undefined {\n    return functionStack.length > 0 ? functionStack[functionStack.length - 1] : undefined;\n  }\n\n  function onlyInInterestingFunction<A extends Function>(fn: A): A {\n    return ((...args: any[]) => {\n      if (currentInteresting()) {\n        return fn(...args);\n      }\n      return undefined;\n    }) as any;\n  }\n\n  /**\n   * For member expressions in interesting functions\n   *\n   * - If their LHS refers to the only function argument; AND\n   *   - If their parent is a `typeof` node; OR\n   *   - The member expression is part of a boolean expression; OR\n   *   - The member expression is in a bang-bang operator (!!); OR\n   *   - The expression is by itself in an `if` or `return` or `?:` ternary\n   *\n   * Then that is a potential problem because it will evaluate a member\n   * that we potentially only wanted to test for presence.\n   */\n  function memberExpression(node: TSESTree.MemberExpression) {\n    const current = currentInteresting()!;\n\n    // Only property access on the primary argument\n    if ((node.object.type !== AST_NODE_TYPES.Identifier) || (node.object as TSESTree.Identifier).name !== current.argumentName) {\n      return;\n    }\n\n    let dangerous = false;\n    if (node.parent.type === AST_NODE_TYPES.UnaryExpression && node.parent.operator === 'typeof') {\n      dangerous = true;\n    }\n    if (node.parent.type === AST_NODE_TYPES.UnaryExpression\n      && node.parent.operator === '!'\n      && node.parent.parent.type === AST_NODE_TYPES.UnaryExpression\n      && node.parent.parent.operator === '!') {\n      dangerous = true;\n    }\n    if (node.parent.type === AST_NODE_TYPES.LogicalExpression && ['&&', '||'].includes(node.parent.operator)) {\n      dangerous = true;\n    }\n    if ([AST_NODE_TYPES.ReturnStatement, AST_NODE_TYPES.IfStatement, AST_NODE_TYPES.ConditionalExpression].includes(node.parent.type)) {\n      dangerous = true;\n    }\n\n    if (dangerous) {\n      const eslintNode = node as MemberExpression;\n      context.report({\n        node: eslintNode,\n        messageId: 'avoidAccess',\n        loc: eslintNode.loc ?? { line: 0, column: 0 },\n        data: {\n          memberAccess: context.sourceCode.getText(eslintNode),\n          obj: current.argumentName,\n          prop: (node.property as TSESTree.PrivateIdentifier | TSESTree.Identifier).name,\n        },\n      });\n    }\n  }\n\n  return {\n    'FunctionDeclaration': enterFunction as any,\n    'FunctionExpression': enterFunction as any,\n    'FunctionDeclaration:exit': exitFunction,\n    'FunctionExpression:exit': exitFunction,\n    'MemberExpression': onlyInInterestingFunction(memberExpression) as any,\n  };\n}\n"]}

package/package.json

@@ -42,6 +42,7 @@
     "@types/node": "^18",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
+    "@typescript-eslint/rule-tester": "^8.52.0",
     "cdklabs-projen-project-types": "^0.3.7",
     "commit-and-tag-version": "^12",
     "constructs": "^10.0.0",
@@ -60,7 +61,9 @@
     "eslint": ">=6 <9"
   },
   "dependencies": {
-    "fs-extra": "^11.3.3"
+    "@typescript-eslint/utils": "^8.52.0",
+    "fs-extra": "^11.3.3",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">= 18.12.0"
@@ -70,7 +73,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.6",
+  "version": "1.4.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [