Rule proposal: Enforce read-only

[sindresorhus]

I would like to enforce function arguments to be read-only (immutable), to prevent me from accidentally mutate user input. I've encountered many modules that accidentally modify a user-supplied options-object.

I would also like to enforce function return values to not be read-only, as that's annoying for users without much benefit, since it's not actually enforced at runtime. This one might be slightly controversial, so could be an option.

Fail

function foo(input: number[]): void {}

function foo(input: string): Readonly<Point> {}

Pass

function foo(input: readonly number[]): void {}

function foo(input: string): Point {}

The rule should support enforcing read-only for:

• readonly (array and tuple)
• readonly (object property)
• Readonly (object properties)
• ReadonlyArray
• readonly for object keys: {readonly [user: string]: boolean}

[kitsonk]

I would like to see the ability to allow the return of read-only values in function arguments (so optional). While it can be annoying, if the internals of a function have retained references to objects/arrays that you expect to be immutable, then you would want to be able to express that intent of "look, but don't touch, or it might get ugly".

[bradzacher]

I was having a look into this (because it's one of our highest-voted issues).
It will require type information though, so that the rule can properly resolve the types to determine if they're readonly:

// file1.ts
export type MyReadonlyType = readonly string[];

// file2.ts
import { MyReadonlyType } from './file1';

function foo(arg: MyReadonlyType) {}

[bradzacher]

Hmmm. Should this check be deeply nested, or just top level?

I.e. would the following types be considered readonly for the purpose of the rule?

type DeepObject = {
  readonly one: {
    two: string;
  };
};

type DeepArray = readonly (string[])[];

[sindresorhus]

Should this check be deeply nested, or just top level?

I would prefer it to check deeply nested.

[bradzacher]

Should methods be treated as "readonly"?
There's no way to create a readonly method, only readonly class properties with function values, and people (almost) always treat them as readonly anyways.

interface Foo {
  bar(): string;
}
declare const x: Foo;

// this is legal, but people "don't" do it
x.bar = () => 'aaa';

---

Edit:

Thinking and researching more here - I think the answer is no.
Why? Because this rule is promoting types that prevent accidental side-effects, and accidentally writing to a method might happen.

In my research, I found that the Readonly type actually works perfectly for classes as well:

class Foo {
    x(): void { }
    readonly y = () => { }
    notReadonly = 1;
}

const test = new Foo();
test.x = () => { };   // no error
test.y = () => { };   // error
test.notReadonly = 2; // no error

function foo(arg: Readonly<Foo>) {
    arg.x = () => { };   // error
    arg.y = () => { };   // error
    arg.notReadonly = 2; // error
}

repl