@codelaw/rules-js 0.0.0-stage → 0.1.0

package/rules/js/no-async-promise-executor.md

@@ -0,0 +1,95 @@
+---
+id: js/no-async-promise-executor
+title: "A Promise executor is not an async function"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the rewrite depends on what the executor does"
+stability: preview
+ported_from: [eslint/no-async-promise-executor]
+since: 0.1.0
+---
+
+The function passed to `new Promise(...)` is not `async`.
+
+**Why:** An error thrown in an async executor doesn't reject the promise, and an executor that needs
+`await` doesn't need the `Promise` wrapper.
+
+```codelaw
+match:
+  any:
+    - pattern: new Promise(async ($$$P) => $$$B)
+    - pattern: new Promise(async function ($$$P) { $$$B })
+    - pattern: new Promise(async $P => $$$B)
+message: "An async Promise executor loses its errors; await inside a plain async function instead"
+```
+
+## How to fix
+
+1. If the executor only awaits and resolves, use the awaited promise directly.
+2. Otherwise make the executor a plain function and handle errors with `reject`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const data = new Promise(async (resolve) => {
+  resolve(await load());
+});
+```
+
+#### Do
+
+```js
+const data = load();
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const data = new Promise(async (resolve) => {
+  resolve(await load());
+});
+```
+
+#### Do
+
+```jsx
+const data = load();
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const data = new Promise(async (resolve) => {
+  resolve(await load());
+});
+```
+
+#### Do
+
+```ts
+const data = load();
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const data = new Promise(async (resolve) => {
+  resolve(await load());
+});
+```
+
+#### Do
+
+```tsx
+const data = load();
+```

package/rules/js/no-case-declarations.md

@@ -0,0 +1,134 @@
+---
+id: js/no-case-declarations
+title: "No let, const, function or class directly in a case"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "another case may rely on the shared declaration"
+stability: preview
+ported_from: [eslint/no-case-declarations]
+since: 0.1.0
+---
+
+A `let`, `const`, `function` or `class` inside a `case` sits in a block `{ … }` of its own.
+
+**Why:** Declarations in a case are scoped to the whole `switch`, so another case can see them
+uninitialised.
+
+```codelaw
+match:
+  any:
+    - kind: lexical_declaration
+    - kind: class_declaration
+    - kind: function_declaration
+  inside:
+    stopBy: neighbor
+    any: [{ kind: switch_case }, { kind: switch_default }]
+message: "A declaration in a case is visible to the whole switch; wrap the case in braces"
+```
+
+## How to fix
+
+1. Wrap the case's statements in `{ … }`.
+2. If another case uses the declaration, move it above the `switch`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+switch (kind) {
+  case "a":
+    const n = 1;
+    use(n);
+    break;
+}
+```
+
+#### Do
+
+```js
+switch (kind) {
+  case "a": {
+    const n = 1;
+    use(n);
+    break;
+  }
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+switch (kind) {
+  case "a":
+    const n = 1;
+    use(n);
+    break;
+}
+```
+
+#### Do
+
+```jsx
+switch (kind) {
+  case "a": {
+    const n = 1;
+    use(n);
+    break;
+  }
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+switch (kind) {
+  case "a":
+    const n = 1;
+    use(n);
+    break;
+}
+```
+
+#### Do
+
+```ts
+switch (kind) {
+  case "a": {
+    const n = 1;
+    use(n);
+    break;
+  }
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+switch (kind) {
+  case "a":
+    const n = 1;
+    use(n);
+    break;
+}
+```
+
+#### Do
+
+```tsx
+switch (kind) {
+  case "a": {
+    const n = 1;
+    use(n);
+    break;
+  }
+}
+```

package/rules/js/no-class-assign.md

@@ -0,0 +1,61 @@
+---
+id: js/no-class-assign
+title: "A class name is not reassigned"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "what the assignment was for is the author's call"
+stability: preview
+ported_from: [eslint/no-class-assign]
+since: 0.1.0
+---
+
+Code doesn't assign a new value to the name a class declaration binds.
+
+**Why:** Reassigning a class name is almost always a mistake, and makes every later use mean
+something else.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, { binding: class }]
+message: "`$$MATCH` is a class; don't assign to it"
+```
+
+## How to fix
+
+1. Assign to a new variable instead of the class name.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Point {}
+Point = null;
+```
+
+#### Do
+
+```js
+class Point {}
+const origin = null;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Point {}
+Point = null;
+```
+
+#### Do
+
+```jsx
+class Point {}
+const origin = null;
+```

package/rules/js/no-compare-neg-zero.md

@@ -0,0 +1,105 @@
+---
+id: js/no-compare-neg-zero
+title: "No comparisons against -0"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether `0` or `-0` was meant needs the author"
+stability: preview
+ported_from: [eslint/no-compare-neg-zero]
+since: 0.1.0
+---
+
+Code doesn't compare a value with `-0` using `==`, `===`, `<` or the other comparison operators.
+
+**Why:** These operators treat `-0` and `0` as equal, so the comparison doesn't test what it says.
+
+```codelaw
+match:
+  kind: binary_expression
+  any:
+    - has: { field: right, pattern: "-0" }
+    - has: { field: left, pattern: "-0" }
+  has:
+    field: operator
+    regex: ^(==|===|!=|!==|<|>|<=|>=)$
+message: "Comparing with -0 is the same as comparing with 0; use Object.is(x, -0) to test for -0"
+```
+
+## How to fix
+
+1. To test for negative zero, use `Object.is(x, -0)`.
+2. To test for zero of either sign, compare with `0`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (x === -0) {
+  flip();
+}
+```
+
+#### Do
+
+```js
+if (Object.is(x, -0)) {
+  flip();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (x === -0) {
+  flip();
+}
+```
+
+#### Do
+
+```jsx
+if (Object.is(x, -0)) {
+  flip();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (x === -0) {
+  flip();
+}
+```
+
+#### Do
+
+```ts
+if (Object.is(x, -0)) {
+  flip();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (x === -0) {
+  flip();
+}
+```
+
+#### Do
+
+```tsx
+if (Object.is(x, -0)) {
+  flip();
+}
+```

package/rules/js/no-cond-assign.md

@@ -0,0 +1,135 @@
+---
+id: js/no-cond-assign
+title: "No assignment in a condition, unless doubly parenthesised"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether a comparison or an assignment was meant needs the author"
+stability: preview
+ported_from: [eslint/no-cond-assign]
+since: 0.1.0
+---
+
+The condition of an `if`, `while`, `do … while` or `for` is not an assignment, unless it is wrapped
+in a second pair of parentheses to say it's meant.
+
+**Why:** `if (a = b)` assigns and tests the result, which is almost always a mistyped `===`.
+
+```codelaw
+match:
+  kind: assignment_expression
+  any:
+    - inside:
+        stopBy: neighbor
+        kind: parenthesized_expression
+        inside:
+          stopBy: neighbor
+          any: [{ kind: if_statement }, { kind: while_statement }, { kind: do_statement }]
+    - inside:
+        stopBy: neighbor
+        kind: expression_statement
+        inside: { stopBy: neighbor, kind: for_statement, field: condition }
+message: "An assignment in a condition is usually a mistyped comparison"
+```
+
+## How to fix
+
+1. If a comparison was meant, use `===`.
+2. If the assignment is meant, wrap it in a second pair of parentheses.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (user = admin) {
+  grant();
+}
+```
+
+#### Do
+
+```js
+if (user === admin) {
+  grant();
+}
+```
+
+```js
+while ((node = node.next)) {
+  visit(node);
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (user = admin) {
+  grant();
+}
+```
+
+#### Do
+
+```jsx
+if (user === admin) {
+  grant();
+}
+```
+
+```jsx
+while ((node = node.next)) {
+  visit(node);
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (user = admin) {
+  grant();
+}
+```
+
+#### Do
+
+```ts
+if (user === admin) {
+  grant();
+}
+```
+
+```ts
+while ((node = node.next)) {
+  visit(node);
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (user = admin) {
+  grant();
+}
+```
+
+#### Do
+
+```tsx
+if (user === admin) {
+  grant();
+}
+```
+
+```tsx
+while ((node = node.next)) {
+  visit(node);
+}
+```

package/rules/js/no-const-assign.md

@@ -0,0 +1,61 @@
+---
+id: js/no-const-assign
+title: "A const is not reassigned"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "whether the variable should be `let` or the assignment should go is the author's call"
+stability: preview
+ported_from: [eslint/no-const-assign]
+since: 0.1.0
+---
+
+Code doesn't assign a new value to a `const`.
+
+**Why:** Assigning to a `const` throws a TypeError at run time.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, { binding: const }]
+message: "`$$MATCH` is a const; assigning to it throws"
+```
+
+## How to fix
+
+1. If the value is meant to change, declare it with `let`.
+2. Otherwise assign to a new variable.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const total = 0;
+total = 1;
+```
+
+#### Do
+
+```js
+let total = 0;
+total = 1;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const total = 0;
+total = 1;
+```
+
+#### Do
+
+```jsx
+let total = 0;
+total = 1;
+```

package/rules/js/no-constant-binary-expression.md

@@ -0,0 +1,83 @@
+---
+id: js/no-constant-binary-expression
+title: "No binary expression whose result is fixed"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the intended grouping or comparison needs the author"
+stability: preview
+ported_from: [eslint/no-constant-binary-expression]
+since: 0.1.0
+---
+
+The left side of `??`, `||` and `&&` is not a value whose nullishness or truthiness is fixed, and
+nothing is compared with a newly created object or with `null` when it can never be `null`.
+
+**Why:** Such an expression always gives the same answer, which usually means the author misread
+operator precedence.
+
+```codelaw
+native: js/no-constant-binary-expression
+```
+
+## How to fix
+
+1. Add the parentheses the expression was meant to have.
+2. Or compare with the value that was meant.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const total = price + tax ?? 0;
+```
+
+#### Do
+
+```js
+const total = price + (tax ?? 0);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const total = price + tax ?? 0;
+```
+
+#### Do
+
+```jsx
+const total = price + (tax ?? 0);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const total = price + tax ?? 0;
+```
+
+#### Do
+
+```ts
+const total = price + (tax ?? 0);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const total = price + tax ?? 0;
+```
+
+#### Do
+
+```tsx
+const total = price + (tax ?? 0);
+```