@codelaw/rules-js 0.0.0-stage → 0.2.0

package/rules/js/no-this-before-super.md

@@ -0,0 +1,74 @@
+---
+id: js/no-this-before-super
+title: "this is not used before super() in a derived constructor"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "moving statements across `super()` can change what the base class sees"
+stability: preview
+ported_from: [eslint/no-this-before-super]
+since: 0.1.0
+---
+
+In the constructor of a class that extends another, `this` and `super.x` are used only after
+`super()` has been called.
+
+**Why:** Before `super()` runs, `this` is not initialised and touching it throws a ReferenceError.
+
+```codelaw
+native: js/no-this-before-super
+```
+
+## How to fix
+
+1. Move the `super(...)` call above the first use of `this`.
+2. If the base class needs a value computed from `this`, compute it into a local first.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Cat extends Animal {
+  constructor() {
+    this.lives = 9;
+    super();
+  }
+}
+```
+
+#### Do
+
+```js
+class Cat extends Animal {
+  constructor() {
+    super();
+    this.lives = 9;
+  }
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Cat extends Animal {
+  constructor() {
+    this.lives = 9;
+    super();
+  }
+}
+```
+
+#### Do
+
+```jsx
+class Cat extends Animal {
+  constructor() {
+    super();
+    this.lives = 9;
+  }
+}
+```

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

@@ -0,0 +1,102 @@
+---
+id: js/no-unassigned-vars
+title: "A variable that is read is also assigned"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the value the variable should hold is the author's"
+stability: preview
+ported_from: [eslint/no-unassigned-vars]
+since: 0.1.0
+---
+
+A variable declared without a value is assigned somewhere before it's read.
+
+**Why:** A variable that is read but never assigned always holds `undefined`, which is a bug or dead
+code.
+
+```codelaw
+match:
+  kind: variable_declarator
+  has: { field: name, kind: identifier, pattern: $N }
+  inside:
+    stopBy: neighbor
+    any: [{ kind: lexical_declaration }, { kind: variable_declaration }]
+  not:
+    any:
+      - has: { field: value, pattern: $VALUE }
+      - inside: { kind: ambient_declaration, stopBy: end }
+where:
+  $N: [{ not: reassigned }, { not: unused }]
+message: "`$N` is read but never assigned, so it's always undefined"
+```
+
+## How to fix
+
+1. Assign the value the variable should hold.
+2. If it's meant to be `undefined`, use `undefined` directly.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+let status;
+report(status);
+```
+
+#### Do
+
+```js
+let status = "ok";
+report(status);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+let status;
+report(status);
+```
+
+#### Do
+
+```jsx
+let status = "ok";
+report(status);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+let status;
+report(status);
+```
+
+#### Do
+
+```ts
+let status = "ok";
+report(status);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let status;
+report(status);
+```
+
+#### Do
+
+```tsx
+let status = "ok";
+report(status);
+```

package/rules/js/no-undef.md

@@ -0,0 +1,76 @@
+---
+id: js/no-undef
+title: "No references to undeclared names"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "the right declaration — an import, a local, or an environment — is the author's call"
+stability: preview
+options:
+  env: { type: "string[]", default: ["shared-node-browser"], description: "environments whose globals are declared: browser, node, commonjs, worker, serviceworker, shared-node-browser, jest, mocha, vitest" }
+  globals: { type: "string[]", default: [], description: "more names to treat as declared" }
+  typeof: { type: "boolean", default: false, description: "also report names used only as `typeof x`" }
+ported_from: [eslint/no-undef]
+since: 0.1.0
+---
+
+Every name the code reads or writes is declared in the file, built into JavaScript, or a global of
+an environment the rule's `env` option names. As in ESLint, a `/* global a, b:writable */` comment
+declares names for that file (`name:off` declares nothing), and a `/* eslint-env node */` comment
+adds environments.
+
+**Why:** An undeclared name is usually a typo or a missing import, and throws a ReferenceError when
+that line runs.
+
+```codelaw
+native: js/no-undef
+```
+
+## How to fix
+
+1. If it's a typo, correct the name.
+2. If it comes from another module, import it.
+3. If it's a global of the runtime (browser, Node), add that environment to the rule's `env` option.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```
+
+#### Do
+
+```js
+const prices = [1, 2];
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```
+
+#### Do
+
+```jsx
+const prices = [1, 2];
+const total = prices.reduce(add, 0);
+function add(a, b) {
+  return a + b;
+}
+```

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