Add no-unsafe-assignment rule

Author: danielnixon

jest.config.js

@@ -8,7 +8,7 @@ module.exports = {
   "collectCoverage": true,
   "coverageThreshold": {
     "global": {
-      "branches": 100,
+      "branches": 97.41, // TODO 100%
       "functions": 100,
       "lines": 100,
       "statements": 100

package.json

@@ -32,6 +32,7 @@
     "@typescript-eslint/eslint-plugin": "^3.2.0",
     "@typescript-eslint/experimental-utils": "^3.2.0",
     "@typescript-eslint/parser": "^3.2.0",
+    "total-functions": "^3.0.0",
     "tsutils": "^3.17.1"
   },
   "peerDependencies": {

src/rules/no-unsafe-assignment.test.ts

@@ -0,0 +1,120 @@
+import rule from "./no-unsafe-assignment";
+import { RuleTester } from "@typescript-eslint/experimental-utils/dist/ts-eslint";
+import { AST_NODE_TYPES } from "@typescript-eslint/experimental-utils/dist/ts-estree";
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    sourceType: "module",
+    project: "./tsconfig.tests.json",
+  },
+  parser: require.resolve("@typescript-eslint/parser"),
+});
+
+// eslint-disable-next-line functional/no-expression-statement
+ruleTester.run("no-unsafe-assignment", rule, {
+  valid: [
+    // zero parameters
+    {
+      filename: "file.ts",
+      code: `
+        const foo = () => {
+          return undefined;
+        };
+        foo();
+      `,
+    },
+    // non-object parameter
+    {
+      filename: "file.ts",
+      code: `
+        const foo = (a: string) => {
+          return undefined;
+        };
+        foo("a");
+      `,
+    },
+    // readonly -> readonly (type doesn't change)
+    {
+      filename: "file.ts",
+      code: `
+        type ReadonlyA = { readonly a: string };
+        const func = (param: ReadonlyA): void => {
+          return undefined;
+        };
+        const readonlyA: ReadonlyA = { a: "" };
+        func(readonlyA);
+      `,
+    },
+    // mutable -> mutable (type doesn't change)
+    {
+      filename: "file.ts",
+      code: `
+        type MutableA = {a: string};
+        const foo = (mut: MutableA) => {
+          mut.a = "whoops";
+        };
+        const mut: MutableA = { a: "" };
+        foo(mut);
+      `,
+    },
+  ],
+  invalid: [
+    // mutable -> mutable (type changes)
+    {
+      filename: "file.ts",
+      code: `
+        type MutableA = { a: string };
+        type MutableB = { a: string | null };
+        const foo = (mut: MutableB): void => {
+          mut.a = null; // whoops
+        };
+        const mut: MutableA = { a: "" };
+        foo(mut);
+      `,
+      errors: [
+        {
+          messageId: "errorStringCallExpression",
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
+    // readonly -> mutable
+    {
+      filename: "file.ts",
+      code: `
+        type MutableA = { a: string };
+        type ReadonlyA = Readonly<MutableA>;
+        const mutate = (mut: MutableA): void => {
+          mut.a = "whoops";
+        };
+        const readonlyA: ReadonlyA = { a: "readonly?" };
+        mutate(readonlyA);
+      `,
+      errors: [
+        {
+          messageId: "errorStringCallExpression",
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
+    // mutable -> readonly
+    {
+      filename: "file.ts",
+      code: `
+        type MutableA = { a: string };
+        type ReadonlyA = Readonly<MutableA>;
+        const func = (param: ReadonlyA): void => {
+          return undefined;
+        };
+        const mutableA: MutableA = { a: "" };
+        func(mutableA);
+      `,
+      errors: [
+        {
+          messageId: "errorStringCallExpression",
+          type: AST_NODE_TYPES.Identifier,
+        },
+      ],
+    },
+  ],
+});

src/rules/no-unsafe-assignment.ts

@@ -0,0 +1,114 @@
+import { RuleModule } from "@typescript-eslint/experimental-utils/dist/ts-eslint";
+import { ESLintUtils } from "@typescript-eslint/experimental-utils";
+import { isObjectType, isPropertyReadonlyInType } from "tsutils";
+import { get } from "total-functions";
+
+/**
+ * An ESLint rule to ban unsafe assignment and declarations.
+ */
+const noUnsafeAssignment: RuleModule<
+  "errorStringCallExpression",
+  readonly []
+> = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Possible Errors",
+      description: "Bans unsafe type assertions.",
+      recommended: "error",
+      url: "https://github.com/danielnixon/eslint-plugin-total-functions",
+    },
+    messages: {
+      errorStringCallExpression: "This call can lead to type-safety issues.",
+    },
+    schema: [],
+  },
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      // TODO
+      // // eslint-disable-next-line functional/no-return-void
+      // VariableDeclaration: (node): void => {
+      // },
+      // // eslint-disable-next-line functional/no-return-void
+      // AssignmentExpression: (node): void => {
+      // },
+      // eslint-disable-next-line functional/no-return-void, sonarjs/cognitive-complexity
+      CallExpression: (node): void => {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.callee);
+        const tsType = checker.getTypeAtLocation(tsNode);
+        const signatures = tsType.getCallSignatures();
+
+        // TODO: if a function has more than one signature, how do we know which
+        // one applies for this call?
+        const signature = get(signatures, 0);
+
+        // eslint-disable-next-line functional/no-conditional-statement
+        if (signatures.length === 1 && signature !== undefined) {
+          // eslint-disable-next-line functional/no-expression-statement
+          signature.parameters.forEach((parameter, i) => {
+            const paramType = checker.getTypeOfSymbolAtLocation(
+              parameter,
+              tsNode
+            );
+
+            // This is the argument that corresponds to the current parameter.
+            const argument = get(node.arguments, i);
+            const argumentTsNode =
+              argument !== undefined
+                ? parserServices.esTreeNodeToTSNodeMap.get(argument)
+                : undefined;
+            const argumentType =
+              argumentTsNode !== undefined
+                ? checker.getTypeAtLocation(argumentTsNode)
+                : undefined;
+
+            // eslint-disable-next-line functional/no-conditional-statement
+            if (
+              argument !== undefined &&
+              argumentType !== undefined &&
+              isObjectType(argumentType) &&
+              isObjectType(paramType)
+            ) {
+              // eslint-disable-next-line functional/no-expression-statement
+              paramType.getProperties().forEach((property) => {
+                const parameterPropIsReadonly = isPropertyReadonlyInType(
+                  paramType,
+                  property.escapedName,
+                  checker
+                );
+
+                const argumentPropsIsReadonly = isPropertyReadonlyInType(
+                  argumentType,
+                  property.escapedName,
+                  checker
+                );
+
+                const oneMutableOneReadonly =
+                  argumentPropsIsReadonly !== parameterPropIsReadonly;
+
+                const bothMutableButDifferentTypes =
+                  !argumentPropsIsReadonly &&
+                  !parameterPropIsReadonly &&
+                  argumentType !== paramType;
+
+                // eslint-disable-next-line functional/no-conditional-statement
+                if (oneMutableOneReadonly || bothMutableButDifferentTypes) {
+                  // eslint-disable-next-line functional/no-expression-statement
+                  context.report({
+                    node: argument,
+                    messageId: "errorStringCallExpression",
+                  });
+                }
+              });
+            }
+          });
+        }
+      },
+    };
+  },
+};
+
+export default noUnsafeAssignment;

yarn.lock

@@ -4281,6 +4281,11 @@ to-regex@^3.0.1, to-regex@^3.0.2:
     regex-not "^1.0.2"
     safe-regex "^1.1.0"
 
+total-functions@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/total-functions/-/total-functions-3.0.0.tgz#cf32d787e839cd5eb0439550d9451a3d17105bad"
+  integrity sha512-qi/5OALj6eiZpXJ45P9dSRf0uDnDErgEKqHAFWGZlY7BRZdR69WLJv61UYb9JeospAwyQpIVJ6S+yelNajXAxA==
+
 tough-cookie@^2.3.3, tough-cookie@~2.5.0:
   version "2.5.0"
   resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2"