@codelaw/rules-js 0.0.0-stage → 0.1.0

package/rules/js/no-unexpected-multiline.md

@@ -0,0 +1,91 @@
+---
+id: js/no-unexpected-multiline
+title: "A line break doesn't silently join two lines into one expression"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether the lines were meant to join can only be known from intent"
+stability: preview
+ported_from: [eslint/no-unexpected-multiline]
+since: 0.1.0
+---
+
+A line that starts with `(`, `[` or a template literal does not continue the expression on the line
+before it without a semicolon.
+
+**Why:** Without semicolons, JavaScript joins such lines: `a\n(b)` is the call `a(b)`, which is
+rarely what was written.
+
+```codelaw
+native: js/no-unexpected-multiline
+```
+
+## How to fix
+
+1. If the lines are separate statements, end the first with a semicolon.
+2. If they are one expression, move the `(` or `[` onto the first line.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const total = sum
+(items).forEach(log);
+```
+
+#### Do
+
+```js
+const total = sum;
+(items).forEach(log);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const total = sum
+(items).forEach(log);
+```
+
+#### Do
+
+```jsx
+const total = sum;
+(items).forEach(log);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const total = sum
+(items).forEach(log);
+```
+
+#### Do
+
+```ts
+const total = sum;
+(items).forEach(log);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const total = sum
+(items).forEach(log);
+```
+
+#### Do
+
+```tsx
+const total = sum;
+(items).forEach(log);
+```

package/rules/js/no-unreachable.md

@@ -0,0 +1,59 @@
+---
+id: js/no-unreachable
+title: "No code after a return, throw, break or continue"
+languages: [javascript, jsx]
+fix: suggest
+fix_reason: "deleting the code is right only when it was really dead, not misplaced"
+stability: preview
+ported_from: [eslint/no-unreachable]
+since: 0.1.0
+---
+
+Statements after an unconditional `return`, `throw`, `break` or `continue` in the same block are
+removed or moved; hoisted function declarations and uninitialised `var`s are allowed.
+
+**Why:** Unreachable code never runs, so it misleads every reader who assumes it does.
+
+```codelaw
+native: js/no-unreachable
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function total(items) {
+  return items.length;
+  log(items);
+}
+```
+
+#### Do
+
+```js
+function total(items) {
+  return items.length;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function total(items) {
+  return items.length;
+  log(items);
+}
+```
+
+#### Do
+
+```jsx
+function total(items) {
+  return items.length;
+}
+```

package/rules/js/no-unsafe-finally.md

@@ -0,0 +1,145 @@
+---
+id: js/no-unsafe-finally
+title: "No return, throw, break or continue in finally"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what should happen to the try block's result is a decision"
+stability: preview
+ported_from: [eslint/no-unsafe-finally]
+since: 0.1.0
+---
+
+A `finally` block doesn't end the function or loop with `return`, `throw`, `break` or `continue`.
+
+**Why:** Control flow in `finally` silently replaces whatever the `try` or `catch` block returned or
+threw.
+
+```codelaw
+match:
+  any:
+    - kind: return_statement
+    - kind: throw_statement
+    - kind: break_statement
+    - kind: continue_statement
+  inside:
+    kind: finally_clause
+    stopBy:
+      any: [{kind: function_declaration}, {kind: function_expression}, {kind: arrow_function}, {kind: method_definition}, {kind: generator_function_declaration}, {kind: generator_function}, { kind: class_declaration }]
+  not:
+    all:
+      - any: [{ kind: break_statement }, { kind: continue_statement }]
+      - inside:
+          stopBy: { kind: finally_clause }
+          any: [{ kind: for_statement }, { kind: for_in_statement }, { kind: while_statement }, { kind: do_statement }, { kind: switch_statement }]
+message: "Control flow in `finally` overrides the try block's return or exception"
+```
+
+## How to fix
+
+1. Move the `return` or `throw` out of `finally` into the `try` or `catch` block.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    return null;
+  }
+}
+```
+
+#### Do
+
+```js
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    cleanup();
+  }
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    return null;
+  }
+}
+```
+
+#### Do
+
+```jsx
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    cleanup();
+  }
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    return null;
+  }
+}
+```
+
+#### Do
+
+```ts
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    cleanup();
+  }
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    return null;
+  }
+}
+```
+
+#### Do
+
+```tsx
+function load() {
+  try {
+    return fetchAll();
+  } finally {
+    cleanup();
+  }
+}
+```

package/rules/js/no-unsafe-negation.md

@@ -0,0 +1,71 @@
+---
+id: js/no-unsafe-negation
+title: "No negating the left side of in or instanceof"
+languages: [javascript, jsx]
+fix: suggest
+fix_reason: "code that really meant `(!a) in b` would change"
+stability: preview
+ported_from: [eslint/no-unsafe-negation]
+since: 0.1.0
+---
+
+`!` before `a in b` or `a instanceof B` wraps the whole test in parentheses.
+
+**Why:** `!a in b` means `(!a) in b`, which tests whether `true` or `false` is a key — never what
+was meant.
+
+```codelaw
+match:
+  kind: binary_expression
+  all:
+    - has: { field: operator, regex: ^(in|instanceof)$ }
+    - has:
+        field: left
+        kind: unary_expression
+        regex: ^!
+        pattern: $NEG
+        has: { field: argument, pattern: $A }
+message: "`!` applies to `$A`, not to the whole test; wrap the test in parentheses"
+fix:
+  - insert-before: "!("
+  - replace: { target: $NEG, with: "$A" }
+  - insert-after: ")"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (!key in cache) {
+  load(key);
+}
+```
+
+#### Do
+
+```js
+if (!(key in cache)) {
+  load(key);
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (!key in cache) {
+  load(key);
+}
+```
+
+#### Do
+
+```jsx
+if (!(key in cache)) {
+  load(key);
+}
+```

package/rules/js/no-unsafe-optional-chaining.md

@@ -0,0 +1,83 @@
+---
+id: js/no-unsafe-optional-chaining
+title: "No ?. chain used where undefined throws"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the right fallback value depends on the code"
+stability: preview
+ported_from: [eslint/no-unsafe-optional-chaining]
+since: 0.1.0
+---
+
+A `?.` chain, which can evaluate to `undefined`, is not called through parentheses, constructed,
+spread into an array or call, destructured, iterated with `for … of`, used on the right of `in` or
+`instanceof`, or extended.
+
+**Why:** In those places `undefined` throws a TypeError, which defeats the point of `?.`.
+
+```codelaw
+native: js/no-unsafe-optional-chaining
+```
+
+## How to fix
+
+1. Give the chain a fallback with `??`.
+2. Or move the `?.` so that it covers the operation that can fail.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const { name } = user?.profile;
+```
+
+#### Do
+
+```js
+const { name } = user?.profile ?? {};
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const { name } = user?.profile;
+```
+
+#### Do
+
+```jsx
+const { name } = user?.profile ?? {};
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const { name } = user?.profile;
+```
+
+#### Do
+
+```ts
+const { name } = user?.profile ?? {};
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const { name } = user?.profile;
+```
+
+#### Do
+
+```tsx
+const { name } = user?.profile ?? {};
+```

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;
+  }
+}
+```