eslint-config-typed 1.0.0

package/src/plugins/total-functions/rules/no-unsafe-mutable-readonly-assignment.test.mts

@@ -0,0 +1,830 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { noUnsafeMutableReadonlyAssignment } from './no-unsafe-mutable-readonly-assignment.mjs';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      sourceType: 'module',
+      project: './tsconfig.tests.json',
+    },
+    parser,
+  },
+});
+
+ruleTester.run(
+  'no-unsafe-mutable-readonly-assignment',
+  noUnsafeMutableReadonlyAssignment,
+  {
+    valid: [
+      /** Call expressions */
+      // zero parameters
+      {
+        filename: 'file.ts',
+        code: `
+        const foo = () => {
+          return undefined;
+        };
+        foo();
+      `,
+      },
+      // zero parameters with extra argument (TypeScript will catch this so we don't flag it)
+      {
+        filename: 'file.ts',
+        code: `
+        const foo = () => {
+          return undefined;
+        };
+        foo("");
+      `,
+      },
+      // non-object parameter
+      {
+        filename: 'file.ts',
+        code: `
+        const foo = (a: string) => {
+          return undefined;
+        };
+        foo("a");
+      `,
+      },
+      // missing arguments (TypeScript will catch this so we don't flag it)
+      {
+        filename: 'file.ts',
+        code: `
+        const foo = (a: string) => {
+          return undefined;
+        };
+        foo();
+      `,
+      },
+      // readonly -> readonly (nested object; type doesn't change)
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyA = { readonly a: { readonly b: string } };
+        const func = (param: ReadonlyA): void => {
+          return undefined;
+        };
+        const readonlyA = { a: { b: "" } } as const;
+        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);
+      `,
+      },
+      // object literal -> mutable (no reference to object retained)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = {a: string};
+        const foo = (mut: MutableA) => {
+          mut.a = "whoops";
+        };
+        foo({ a: "" });
+      `,
+      },
+      // object literal -> mutable (mutable reference to property retained)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableB = { b: string };
+        type MutableA = { readonly a: MutableB };
+        const func = (param: MutableA): void => {
+          return undefined;
+        };
+        const b: MutableB = { b: "" };
+        func({ a: b } as const);
+      `,
+      },
+      // object literal -> readonly (readonly reference to property retained)
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyB = { readonly b: string };
+        type ReadonlyA = { readonly a: ReadonlyB };
+        const func = (param: ReadonlyA): void => {
+          return undefined;
+        };
+        const b: ReadonlyB = { b: "" } as const;
+        func({ a: b } as const);
+      `,
+      },
+      // object literal -> readonly (no reference to object or its property retained)
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyB = { readonly b: string };
+        type ReadonlyA = { readonly a: ReadonlyB };
+        const func = (param: ReadonlyA): void => {
+          return undefined;
+        };
+        func({ a: { b: "" } } as const);
+      `,
+      },
+      // mutable (union) -> mutable
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = {a: string};
+        const foo = (mut: MutableA) => {
+          mut.a = "whoops";
+        };
+        const mut: MutableA | number = { a: "" };
+        foo(mut);
+      `,
+      },
+      // mutable -> mutable (union)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = {a: string};
+        const foo = (mut: MutableA | number): void => {
+          return;
+        };
+        const mut: MutableA = { a: "" };
+        foo(mut);
+      `,
+      },
+      // multiple type signatures (readonly -> readonly)
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyA = { readonly a: string };
+
+        export function func(a: number): number;
+        export function func(a: ReadonlyA): ReadonlyA;
+        export function func(a: any): any {
+          return a;
+        }
+
+        const readonlyA: ReadonlyA = { a: "" } as const;
+        func(readonlyA);
+      `,
+      },
+      // multiple type signatures (no matching signature)
+      // we don't bother flagging this because TypeScript itself will catch it
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyA = { readonly a: string };
+
+        export function func(a: number): number;
+        export function func(a: string): string;
+        export function func(a: any): any {
+          return a;
+        }
+
+        const readonlyA: ReadonlyA = { a: "" } as const;
+        func(readonlyA);
+      `,
+      },
+      // readonly array concat.
+      {
+        filename: 'file.ts',
+        code: `
+        const arr: ReadonlyArray<never> = [] as const;
+        const foo = arr.concat(arr, arr);
+      `,
+      },
+      // TODO: https://github.com/danielnixon/eslint-plugin-total-functions/issues/132
+      // // mutable array concat.
+      // {
+      //   filename: "file.ts",
+      //   code: `
+      //     const arr: Array<never> = [];
+      //     const foo = arr.concat(arr, arr);
+      //   `,
+      // },
+      // // Mixed mutable and readonly array concat.
+      // {
+      //   filename: "file.ts",
+      //   code: `
+      //     const ro: ReadonlyArray<never> = [] as const;
+      //     const mut: Array<never> = [];
+      //     const foo = ro.concat(ro, mut);
+      //   `,
+      // },
+      // mixed (union) -> mixed (union)
+      // The `readonly`s align and `mutable`s align, so no surprising mutation can arise.
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a: string };
+        type ReadonlyB = { readonly b: string };
+        const func = (foo: MutableA | ReadonlyB): void => {
+          return;
+        };
+        const foo: MutableA | ReadonlyB = Date.now() > 0 ? { a: "" } : { b: "" } as const;
+        func(foo);
+      `,
+      },
+      // readonly array of readonly object -> readonly array of readonly object
+      {
+        filename: 'file.ts',
+        code: `
+        type Obj = { readonly foo: string };
+        const foo = (a: ReadonlyArray<Obj>): number => a.length;
+        const arr: ReadonlyArray<Obj> = [] as const;
+        foo(arr);
+      `,
+      },
+      /** Assignment expressions */
+      // TODO
+      // Array safe mutable to readonly assignment with chained array operations.
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray: readonly string[] = fooArray.filter((v) => v.length > 0).map((v) => v.length.toString());
+      `,
+      },
+      // Array safe mutable to readonly assignment. (array.filter)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = [""] as const;
+        const nextArray: readonly string[] = fooArray.filter((v) => v.length > 0);
+      `,
+      },
+      // Array safe mutable to readonly assignment. (array.map)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray: readonly string[] = fooArray.map((v) => v.length.toString());
+      `,
+      },
+      // Array safe mutable to readonly assignment. (array.concat)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test-1"] as const;
+        const booArray: readonly string[] = ["test-2"] as const;
+        const nextArray: readonly string[] = fooArray.concat(booArray);
+      `,
+      },
+      // Array safe mutable to readonly assignment. (array.flatMap)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[][] = [["test"]] as const;
+        const nextArray: readonly string[] = fooArray.flatMap((v) => v.length.toString());
+      `,
+      },
+      // Array safe mutable to readonly assignment. (array.flat)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[][] = [["test"]] as const;
+        const nextArray: readonly string[] = fooArray.flat();
+      `,
+      },
+      // Array safe mutable to readonly assignment. (array.slice)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray: readonly string[] = fooArray.slice();
+      `,
+      },
+      /** Return statement */
+      // mutable -> mutable (function return)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a: string };
+        type ReadonlyA = { readonly a: string };
+
+        function foo(): MutableA {
+          const ma: MutableA = { a: "" };
+          return ma;
+        }
+      `,
+      },
+      // readonly -> readonly (function return)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a: string };
+        type ReadonlyA = { readonly a: string };
+
+        function foo(): ReadonlyA {
+          const ma: ReadonlyA = { a: "" } as const;
+          return ma;
+        }
+      `,
+      },
+      // 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);
+      `,
+      },
+      // tuple -> readonly array (nested objected property)
+      {
+        filename: 'file.ts',
+        code: `
+        type Foo = {
+          readonly foo: ReadonlyArray<{
+            readonly a: string;
+            readonly b: string;
+          }>;
+        };
+
+        const f: Foo = {
+          foo: [{
+            a: "",
+            b: "",
+          }],
+        } as const;
+      `,
+      },
+      // mutable function return -> mutable function return (multiple call signatures).
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a: string };
+
+        interface MutableFunc {
+          (b: number): MutableA;
+          (b: string): MutableA;
+        }
+
+        const mf: MutableFunc = (b: number | string): MutableA => {
+          return { a: "" };
+        };
+
+        const rf: MutableFunc = mf;
+      `,
+      },
+      // readonly function return -> readonly function return (multiple call signatures).
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyA = { readonly a: string };
+
+        interface ReadonlyFunc {
+          (b: number): ReadonlyA;
+          (b: string): ReadonlyA;
+        }
+
+        const mf: ReadonlyFunc = (b: number | string): ReadonlyA => {
+          return { a: "" } as const;
+        };
+
+        const rf: ReadonlyFunc = mf;
+      `,
+      },
+      // Return empty tuple from function that is declared to return some readonly array type.
+      {
+        filename: 'file.ts',
+        code: `
+        type Foo = ReadonlyArray<{ readonly a: string }>;
+        const foo = (): Foo => {
+          return [] as const;
+        };
+      `,
+      },
+      // Return empty tuple from function that is declared to return empty tuple.
+      {
+        filename: 'file.ts',
+        code: `
+        type Foo = readonly [];
+        const foo = (): Foo => {
+          return [] as const;
+        };
+      `,
+      },
+      // Return safe mutable array with chained array operations.
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray = (): readonly string[] => fooArray.filter((v) => v.length > 0).map((v) => v.length.toString());
+      `,
+      },
+      // Return safe mutable array. (array.filter)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = [""] as const;
+        const nextArray = (): readonly string[] => fooArray.filter((v) => v.length > 0);
+      `,
+      },
+      // Return safe mutable array. (array.map)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray = (): readonly string[] => fooArray.map((v) => v.length.toString());
+      `,
+      },
+      // Return safe mutable array. (array.concat)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test-1"] as const;
+        const booArray: readonly string[] = ["test-2"] as const;
+        const nextArray = (): readonly string[] => fooArray.concat(booArray);
+      `,
+      },
+      // Return safe mutable array. (array.flatMap)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[][] = [["test"]] as const;
+        const nextArray = (): readonly string[] => fooArray.flatMap((v) => v.length.toString());
+      `,
+      },
+      // Return safe mutable array. (array.flat)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[][] = [["test"]] as const;
+        const nextArray = (): readonly string[] => fooArray.flat();
+      `,
+      },
+      // Return safe mutable array. (array.slice)
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray = (): readonly string[] => fooArray.slice();
+      `,
+      },
+      // Return safe mutable array.
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        const nextArray = (): readonly string[] => {
+          return fooArray.slice();
+        }
+      `,
+      },
+      // Yield safe mutable array.
+      {
+        filename: 'file.ts',
+        code: `
+        const fooArray: readonly string[] = ["test"] as const;
+        export function* mySaga(): Generator<readonly string[]> {
+          yield fooArray.slice();
+        }
+      `,
+      },
+      // generators
+      {
+        filename: 'file.ts',
+        code: `
+        export function* mySaga(): Generator<void> {
+          yield;
+        }
+      `,
+      },
+      // The five turtles.
+      // https://effectivetypescript.com/2021/05/06/unsoundness/#There-Are-Five-Turtles
+      // https://www.youtube.com/watch?v=wpgKd-rwnMw&t=1714s
+      {
+        filename: 'file.ts',
+        code: `
+        type Foo<U> = {
+          readonly a: U;
+          readonly b: Foo<Foo<U>>;
+        };
+
+        type Bar<U> = {
+          readonly a: U;
+          readonly b: Bar<Bar<U>>;
+        };
+
+        declare const foo: Foo<string>;
+
+        const bar: Bar<string> = foo;
+      `,
+      },
+      {
+        filename: 'file.ts',
+        code: `
+        type Foo<U> = {
+          readonly a: U;
+          readonly b: () => Foo<Foo<U>>;
+        };
+
+        type Bar<U> = {
+          readonly a: U;
+          readonly b: () => Bar<Bar<U>>;
+        };
+
+        declare const foo: Foo<string>;
+
+        const bar: Bar<string> = foo;
+      `,
+      },
+      // Return empty array literal from function that is declared to return empty tuple.
+      {
+        filename: 'file.ts',
+        code: `
+        const foo = (): readonly [] => {
+          return [];
+        };
+      `,
+      },
+      // https://github.com/danielnixon/eslint-plugin-total-functions/issues/741
+      {
+        filename: 'file.ts',
+        code: `
+        type Foo<U> = {
+          b?: Foo<Foo<U>>;
+        };
+
+        const takesAFoo = <U>(foo: Foo<U>): void => {
+          return undefined;
+        }
+
+        let foo: Foo<unknown> = { b: {} };
+
+        foo.b = foo;
+
+        takesAFoo(foo);
+      `,
+      },
+      {
+        filename: 'file.ts',
+        code: `
+        declare const fooArray: readonly string[];
+        declare const takesReadonly: (a: readonly string[]) => void;
+        const nextArray: readonly string[] = takesReadonly(fooArray.slice());
+      `,
+      },
+      // Literal (mutable) assigned to immutable but safe because no surprising mutation can arise
+      {
+        filename: 'file.ts',
+        code: `
+        const o: readonly string[] = [];
+      `,
+      },
+    ],
+    invalid: [
+      // initialization using mutable (literal) -> readonly
+      // TODO this should ideally be considered valid without requiring an `as const`.
+      {
+        filename: 'file.ts',
+        code: `
+        type ReadonlyA = { readonly a: string };
+        const readonlyA: ReadonlyA = { a: "" };
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.VariableDeclaration,
+          },
+        ],
+      },
+      // TODO `{ a: b } as const` is being flagged here. Is that correct?
+      // // object literal -> readonly (mutable reference to property retained)
+      // {
+      //   filename: "file.ts",
+      //   code: `
+      //     type MutableB = { b: string };
+      //     type ReadonlyA = { readonly a: { readonly b: string } };
+      //     const func = (param: ReadonlyA): void => {
+      //       return undefined;
+      //     };
+      //     const b: MutableB = { b: "" };
+      //     func({ a: b } as const);
+      //   `,
+      //   errors: [
+      //     {
+      //       messageId: "errorStringGeneric",
+      //       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: 'errorStringGeneric',
+            type: AST_NODE_TYPES.Identifier,
+          },
+        ],
+      },
+      // mutable -> readonly (function return)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a: string };
+        type ReadonlyA = { readonly a: string };
+
+        function foo(): ReadonlyA {
+          const ma: MutableA = { a: "" };
+          return ma;
+        }
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.ReturnStatement,
+          },
+        ],
+      },
+      // mutable object prop -> readonly object prop (as part of intersection with non-object).
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a?: string } & number;
+        type ReadonlyA = { readonly a?: string } & number;
+
+        const ma: MutableA = 42;
+        const ra: ReadonlyA = ma;
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.VariableDeclaration,
+          },
+        ],
+      },
+      // mutable function value -> readonly.
+      {
+        filename: 'file.ts',
+        code: `
+        type MyType = {
+          readonly filter: () => Record<string, string>;
+        };
+
+        const myValue: MyType = {
+          filter: () => ({ foo: "bar" }),
+        } as const;
+
+        const foo: Readonly<Record<string, string>> = myValue.filter();
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.VariableDeclaration,
+          },
+        ],
+      },
+      // mutable function array value -> readonly.
+      {
+        filename: 'file.ts',
+        code: `
+        type MyType = {
+          readonly filter: () => string[];
+        };
+
+        const myValue: MyType = {
+          filter: () => (["bar"]),
+        } as const;
+
+        const foo: readonly string[] = myValue.filter();
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.VariableDeclaration,
+          },
+        ],
+      },
+      {
+        filename: 'file.ts',
+        code: `
+        type MyReadonlyType = { readonly a: string };
+        type MyMutableType = { a: string };
+
+        const mutableVal: MyMutableType = { a: "" };
+        const readonlyArrayOfMutable: readonly MyMutableType[] = [mutableVal] as const;
+
+        const shouldBeImmutable: readonly MyReadonlyType[] =
+          readonlyArrayOfMutable.concat({
+            a: "",
+          });
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.VariableDeclaration,
+          },
+        ],
+      },
+      // yield expression (generator)
+      {
+        filename: 'file.ts',
+        code: `
+        type MutableA = { a: string };
+        type ReadonlyA = { readonly a: string };
+
+        export function* mySaga(): Generator<ReadonlyA> {
+          const foo: MutableA = { a: "" };
+          yield foo;
+        }
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.YieldExpression,
+          },
+        ],
+      },
+      // deep(ish) type
+      {
+        filename: 'file.ts',
+        code: `
+        type A = {
+          a: string;
+        };
+
+        type B = {
+          readonly a: A;
+        };
+
+        type C = {
+          readonly b: B;
+        };
+
+        type D = {
+          readonly c: C;
+        };
+
+        type E = {
+          readonly d: D;
+        };
+
+        type F = {
+          readonly e: E;
+        };
+
+        type G = {
+          readonly f: F;
+        };
+
+        type A2 = {
+          readonly a: string;
+        };
+
+        type B2 = {
+          readonly a: A2;
+        };
+
+        type C2 = {
+          readonly b: B2;
+        };
+
+        type D2 = {
+          readonly c: C2;
+        };
+
+        type E2 = {
+          readonly d: D2;
+        };
+
+        type F2 = {
+          readonly e: E2;
+        };
+
+        type G2 = {
+          readonly f: F2;
+        };
+
+        declare const g: G;
+        export const g2: G2 = g;
+      `,
+        errors: [
+          {
+            messageId: 'errorStringGeneric',
+            type: AST_NODE_TYPES.VariableDeclaration,
+          },
+        ],
+      },
+    ],
+  } as const,
+);