@codelaw/rules-js 0.0.0-stage → 0.2.0

package/rules/js/no-unused-labels.md

@@ -0,0 +1,102 @@
+---
+id: js/no-unused-labels
+title: "Every label is used"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-unused-labels]
+since: 0.1.0
+---
+
+Every statement label is the target of a `break` or `continue`.
+
+**Why:** An unused label is leftover from a refactor and makes the reader look for a jump that isn't
+there.
+
+```codelaw
+match:
+  kind: labeled_statement
+  all:
+    - has: { field: label, pattern: $L }
+    - has: { field: body, pattern: $BODY }
+  not:
+    has:
+      stopBy: end
+      any: [{ pattern: "break $L;" }, { pattern: "continue $L;" }]
+message: "The label `$L` is never used"
+fix: "$BODY"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+outer: for (const row of rows) {
+  draw(row);
+}
+```
+
+#### Do
+
+```js
+for (const row of rows) {
+  draw(row);
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+outer: for (const row of rows) {
+  draw(row);
+}
+```
+
+#### Do
+
+```jsx
+for (const row of rows) {
+  draw(row);
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+outer: for (const row of rows) {
+  draw(row);
+}
+```
+
+#### Do
+
+```ts
+for (const row of rows) {
+  draw(row);
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+outer: for (const row of rows) {
+  draw(row);
+}
+```
+
+#### Do
+
+```tsx
+for (const row of rows) {
+  draw(row);
+}
+```

package/rules/js/no-unused-private-class-members.md

@@ -0,0 +1,126 @@
+---
+id: js/no-unused-private-class-members
+title: "Every private class member is read"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "removing a member may also remove writes that matter, so it's a reader's call"
+stability: preview
+ported_from: [eslint/no-unused-private-class-members]
+since: 0.1.0
+---
+
+A private field, method or accessor (`#name`) is read somewhere in its class; only being written
+doesn't count.
+
+**Why:** A private member nothing reads is dead code, since nothing outside the class can reach it.
+
+```codelaw
+native: js/no-unused-private-class-members
+```
+
+## How to fix
+
+1. Check that nothing needs the member's value.
+2. Remove the member and the writes to it, or read it where it was meant to be used.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Counter {
+  #count = 0;
+  #unused = 1;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+#### Do
+
+```js
+class Counter {
+  #count = 0;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Counter {
+  #count = 0;
+  #unused = 1;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+#### Do
+
+```jsx
+class Counter {
+  #count = 0;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+class Counter {
+  #count = 0;
+  #unused = 1;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+#### Do
+
+```ts
+class Counter {
+  #count = 0;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+class Counter {
+  #count = 0;
+  #unused = 1;
+  get value() {
+    return this.#count;
+  }
+}
+```
+
+#### Do
+
+```tsx
+class Counter {
+  #count = 0;
+  get value() {
+    return this.#count;
+  }
+}
+```

package/rules/js/no-unused-vars.md

@@ -0,0 +1,69 @@
+---
+id: js/no-unused-vars
+title: "Every declared name is used"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "removing a declaration can drop the side effects of its initialiser"
+stability: preview
+options:
+  vars: { type: string, default: all, description: "all, or local to skip module-level names" }
+  args: { type: string, default: after-used, description: "after-used, all or none" }
+  caughtErrors: { type: string, default: all, description: "all or none" }
+  ignoreRestSiblings: { type: boolean, default: false }
+  varsIgnorePattern: { type: string, description: "a regular expression of names to skip" }
+  argsIgnorePattern: { type: string }
+  caughtErrorsIgnorePattern: { type: string }
+  destructuredArrayIgnorePattern: { type: string }
+ported_from: [eslint/no-unused-vars]
+since: 0.1.0
+---
+
+Every variable, function, class, import, parameter and caught error is read somewhere. Parameters
+before the last used one are allowed (`args: after-used`).
+
+**Why:** An unused declaration is either dead code or a sign the code doesn't do what it was meant
+to.
+
+```codelaw
+native: js/no-unused-vars
+```
+
+## How to fix
+
+1. Check the initialiser has no side effect that matters.
+2. Remove the declaration, or use it where it was meant to be used.
+3. For a parameter that must stay for its position, prefix it with `_` and set `argsIgnorePattern: "^_"`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+import { readFile, writeFile } from "node:fs";
+export const load = (path) => readFile(path);
+```
+
+#### Do
+
+```js
+import { readFile } from "node:fs";
+export const load = (path) => readFile(path);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+import { readFile, writeFile } from "node:fs";
+export const load = (path) => readFile(path);
+```
+
+#### Do
+
+```jsx
+import { readFile } from "node:fs";
+export const load = (path) => readFile(path);
+```

package/rules/js/no-useless-assignment.md

@@ -0,0 +1,115 @@
+---
+id: js/no-useless-assignment
+title: "No value is stored that nothing reads"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether the store is dead or the read is missing needs the author"
+stability: preview
+ported_from: [eslint/no-useless-assignment]
+since: 0.1.0
+---
+
+A variable is not assigned a value that is overwritten before anything reads it, or that nothing
+reads after the assignment.
+
+**Why:** A dead store is wasted work and usually means the code reads the wrong variable.
+
+```codelaw
+native: js/no-useless-assignment
+```
+
+## How to fix
+
+1. If the value is not needed, remove the assignment.
+2. If it should be read, read it where it was meant to be used.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```js
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```jsx
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```ts
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function total(items) {
+  let sum = 0;
+  sum = items.length;
+  return sum;
+}
+```
+
+#### Do
+
+```tsx
+function total(items) {
+  const sum = items.length;
+  return sum;
+}
+```
+
+## Differences from the source
+
+Only stores a straight-line reading proves dead are reported: an overwrite in the same block, or a
+last assignment outside any loop. A variable a nested function touches is skipped.

package/rules/js/no-useless-backreference.md

@@ -0,0 +1,83 @@
+---
+id: js/no-useless-backreference
+title: "No backreference that can only match the empty string"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the reference was meant to repeat needs the author"
+stability: preview
+ported_from: [eslint/no-useless-backreference]
+since: 0.1.0
+---
+
+A backreference such as `\1` or `\k<name>` appears after its group closes, in the same alternative,
+and not into a negative lookaround.
+
+**Why:** A backreference that comes first, sits inside its own group or in another alternative
+always matches the empty string.
+
+```codelaw
+native: js/no-useless-backreference
+```
+
+## How to fix
+
+1. Move the backreference after the group it refers to.
+2. Or remove it if it was meant to be literal text.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /\1(a)/;
+```
+
+#### Do
+
+```js
+const re = /(a)\1/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /\1(a)/;
+```
+
+#### Do
+
+```jsx
+const re = /(a)\1/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /\1(a)/;
+```
+
+#### Do
+
+```ts
+const re = /(a)\1/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /\1(a)/;
+```
+
+#### Do
+
+```tsx
+const re = /(a)\1/;
+```

package/rules/js/no-useless-catch.md

@@ -0,0 +1,105 @@
+---
+id: js/no-useless-catch
+title: "No catch that only rethrows"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "removing the try block changes the scope of declarations inside it"
+stability: preview
+ported_from: [eslint/no-useless-catch]
+since: 0.1.0
+---
+
+A `catch` clause does more than rethrow the error it caught.
+
+**Why:** `catch (e) { throw e; }` does nothing but add noise and a level of nesting.
+
+```codelaw
+match:
+  kind: catch_clause
+  all:
+    - has: { field: parameter, pattern: $E }
+    - has:
+        field: body
+        regex: ^\{\s*throw\s+[A-Za-z_$][A-Za-z0-9_$]*\s*;?\s*\}$
+        has: { kind: throw_statement, has: { pattern: $E }, stopBy: end }
+message: "This catch only rethrows `$E`; remove it"
+```
+
+## How to fix
+
+1. If there is no `finally`, replace the `try` statement with the statements of its block.
+2. If there is a `finally`, remove only the `catch` clause.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```js
+load();
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```jsx
+load();
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```ts
+load();
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (e) {
+  throw e;
+}
+```
+
+#### Do
+
+```tsx
+load();
+```

package/rules/js/no-useless-escape.md

@@ -0,0 +1,81 @@
+---
+id: js/no-useless-escape
+title: "No backslash that changes nothing"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-useless-escape]
+since: 0.1.0
+---
+
+A string or template literal escapes only characters that need it: quotes that match the delimiter,
+`\\`, line breaks and the escape letters.
+
+**Why:** A useless escape suggests the author meant something else, and makes the string harder to
+read.
+
+```codelaw
+native: js/no-useless-escape
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const path = "a\.b";
+```
+
+#### Do
+
+```js
+const path = "a.b";
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const path = "a\.b";
+```
+
+#### Do
+
+```jsx
+const path = "a.b";
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const path = "a\.b";
+```
+
+#### Do
+
+```ts
+const path = "a.b";
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const path = "a\.b";
+```
+
+#### Do
+
+```tsx
+const path = "a.b";
+```
+
+## Differences from the source
+
+Escapes inside regular expressions are not checked yet. A tagged template (`String.raw`, `html`) is not checked: its tag sees the raw text, backslashes included, as in ESLint.