@codelaw/rules-js 0.0.0-stage → 0.2.0

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

package/rules/js/no-constant-condition.md

@@ -0,0 +1,150 @@
+---
+id: js/no-constant-condition
+title: "No conditions that are always true or always false"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether to remove the branch or fix the condition needs the author"
+stability: preview
+ported_from: [eslint/no-constant-condition]
+since: 0.1.0
+---
+
+The condition of an `if`, `while` or `do … while` is not a literal or another value that is always
+truthy or always falsy; `while (true)` is allowed.
+
+**Why:** A constant condition is usually leftover debugging or a typo, and hides dead code.
+
+```codelaw
+match:
+  kind: parenthesized_expression
+  inside:
+    stopBy: neighbor
+    any: [{ kind: if_statement }, { kind: while_statement }, { kind: do_statement }]
+    field: condition
+  has:
+    stopBy: neighbor
+    any:
+      - kind: number
+      - kind: string
+      - kind: "true"
+      - kind: "false"
+      - kind: "null"
+      - kind: undefined
+      - kind: array
+      - kind: object
+      - kind: arrow_function
+      - kind: function_expression
+      - kind: regex
+  not:
+    all:
+      - inside: { stopBy: neighbor, kind: while_statement }
+      - has: { stopBy: neighbor, kind: "true" }
+message: "This condition is a constant, so the branch always or never runs"
+```
+
+## How to fix
+
+1. If the branch is dead, remove it.
+2. Otherwise replace the constant with the condition that was meant.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```js
+if (debug) {
+  debugPanel();
+}
+```
+
+```js
+while (true) {
+  step();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```jsx
+if (debug) {
+  debugPanel();
+}
+```
+
+```jsx
+while (true) {
+  step();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```ts
+if (debug) {
+  debugPanel();
+}
+```
+
+```ts
+while (true) {
+  step();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (0) {
+  debugPanel();
+}
+```
+
+#### Do
+
+```tsx
+if (debug) {
+  debugPanel();
+}
+```
+
+```tsx
+while (true) {
+  step();
+}
+```
+
+## Differences from the source
+
+Only literal conditions are checked; ESLint also folds some expressions such as `typeof x` and `!1`.

package/rules/js/no-control-regex.md

@@ -0,0 +1,84 @@
+---
+id: js/no-control-regex
+title: "No control characters in regular expressions"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "which character was meant needs the author"
+stability: preview
+ported_from: [eslint/no-control-regex]
+since: 0.1.0
+---
+
+A regular expression literal doesn't match ASCII control characters (`\x00`–`\x1F`).
+
+**Why:** Control characters rarely appear in text, so matching them is usually an escaping mistake.
+
+```codelaw
+match:
+  kind: regex_pattern
+  regex: \\x[01][0-9a-fA-F]|\\u00[01][0-9a-fA-F]|[\x00-\x1f]
+message: "Control characters in a regular expression are almost always a mistake"
+```
+
+## How to fix
+
+1. Use the named escape (`\t`, `\n`, `\f`) if one was meant.
+2. Otherwise remove the control character from the pattern.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const re = /\x0C/;
+```
+
+#### Do
+
+```js
+const re = /\f/;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const re = /\x0C/;
+```
+
+#### Do
+
+```jsx
+const re = /\f/;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const re = /\x0C/;
+```
+
+#### Do
+
+```ts
+const re = /\f/;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const re = /\x0C/;
+```
+
+#### Do
+
+```tsx
+const re = /\f/;
+```

package/rules/js/no-debugger.md

@@ -0,0 +1,99 @@
+---
+id: js/no-debugger
+title: "No debugger statements"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-debugger]
+since: 0.1.0
+---
+
+Code contains no `debugger` statements.
+
+**Why:** `debugger` pauses execution wherever developer tools are open, which nobody wants in
+shipped code.
+
+```codelaw
+match:
+  kind: debugger_statement
+message: "Remove `debugger` before committing"
+fix: [remove]
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```js
+function load() {
+  return fetchAll();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```jsx
+function load() {
+  return fetchAll();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```ts
+function load() {
+  return fetchAll();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function load() {
+  debugger;
+  return fetchAll();
+}
+```
+
+#### Do
+
+```tsx
+function load() {
+  return fetchAll();
+}
+```