@codelaw/rules-js 0.0.0-stage → 0.2.0

package/rules/js/no-empty-pattern.md

@@ -0,0 +1,86 @@
+---
+id: js/no-empty-pattern
+title: "No empty destructuring patterns"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "what the pattern was meant to bind needs the author"
+stability: preview
+ported_from: [eslint/no-empty-pattern]
+since: 0.1.0
+---
+
+A destructuring pattern names at least one binding.
+
+**Why:** `const {} = obj` binds nothing; it's usually a mistyped default such as `{ a = {} }`.
+
+```codelaw
+match:
+  any:
+    - kind: object_pattern
+      regex: ^\{\s*\}$
+    - kind: array_pattern
+      regex: ^\[\s*\]$
+message: "This destructuring pattern binds nothing"
+```
+
+## How to fix
+
+1. Name the properties to bind inside the pattern, or remove it.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const { a: {} } = options;
+```
+
+#### Do
+
+```js
+const { a = {} } = options;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const { a: {} } = options;
+```
+
+#### Do
+
+```jsx
+const { a = {} } = options;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const { a: {} } = options;
+```
+
+#### Do
+
+```ts
+const { a = {} } = options;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const { a: {} } = options;
+```
+
+#### Do
+
+```tsx
+const { a = {} } = options;
+```

package/rules/js/no-empty-static-block.md

@@ -0,0 +1,99 @@
+---
+id: js/no-empty-static-block
+title: "No empty static blocks"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-empty-static-block]
+since: 0.1.0
+---
+
+A class has no empty `static { }` block.
+
+**Why:** An empty static block does nothing; it is leftover or unfinished code.
+
+```codelaw
+match:
+  kind: class_static_block
+  regex: ^static\s*\{\s*\}$
+message: "Empty static block"
+fix: [remove]
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```js
+class Config {
+  load() {}
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```jsx
+class Config {
+  load() {}
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```ts
+class Config {
+  load() {}
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+class Config {
+  static {}
+  load() {}
+}
+```
+
+#### Do
+
+```tsx
+class Config {
+  load() {}
+}
+```

package/rules/js/no-empty.md

@@ -0,0 +1,116 @@
+---
+id: js/no-empty
+title: "No empty blocks"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether to fill the block, remove it or document it needs the author"
+stability: preview
+ported_from: [eslint/no-empty]
+since: 0.1.0
+---
+
+A block or `switch` has at least one statement, or a comment saying why it is empty. Function bodies
+may be empty.
+
+**Why:** An empty block is usually unfinished code, and an empty `catch` hides errors.
+
+```codelaw
+match:
+  any:
+    - kind: statement_block
+      regex: ^\{\s*\}$
+      not:
+        inside:
+          stopBy: neighbor
+          any: [{kind: function_declaration}, {kind: function_expression}, {kind: arrow_function}, {kind: method_definition}, {kind: generator_function_declaration}, {kind: generator_function}, { kind: class_static_block }]
+    - kind: switch_statement
+      has: { field: body, regex: '^\{\s*\}$' }
+message: "Empty block; remove it or say why it's empty"
+```
+
+## How to fix
+
+1. If the block is unfinished, write its code.
+2. If it's meant to be empty, put a comment in it saying why.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```js
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```jsx
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```ts
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (e) {}
+```
+
+#### Do
+
+```tsx
+try {
+  load();
+} catch (e) {
+  // The cache is optional: a failed load is not an error.
+}
+```

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

@@ -0,0 +1,121 @@
+---
+id: js/no-ex-assign
+title: "A caught error is not reassigned"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "where the original error should go is a decision"
+stability: preview
+ported_from: [eslint/no-ex-assign]
+since: 0.1.0
+---
+
+Code doesn't assign a new value to the parameter of a `catch` clause.
+
+**Why:** Reassigning the caught error discards it, so nothing can report or rethrow it.
+
+```codelaw
+match:
+  kind: identifier
+where:
+  $$MATCH: [write, { binding: catch-param }]
+message: "Assigning to the caught error `$$MATCH` loses it"
+```
+
+## How to fix
+
+1. Use a new variable for the new value.
+2. Keep the original error, e.g. as `{ cause: err }`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```js
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```jsx
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```ts
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (err) {
+  err = new Error("failed");
+  throw err;
+}
+```
+
+#### Do
+
+```tsx
+try {
+  load();
+} catch (err) {
+  throw new Error("failed", { cause: err });
+}
+```

package/rules/js/no-extra-boolean-cast.md

@@ -0,0 +1,107 @@
+---
+id: js/no-extra-boolean-cast
+title: "No needless !! or Boolean() in a condition"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/no-extra-boolean-cast]
+since: 0.1.0
+---
+
+A condition (`if`, `while`, `do … while`, `? :`) doesn't convert its value with `!!`.
+
+**Why:** A condition is already evaluated as a boolean, so `!!` only adds noise.
+
+```codelaw
+match:
+  pattern: "!!$X"
+  any:
+    - inside:
+        stopBy: neighbor
+        kind: parenthesized_expression
+        inside:
+          stopBy: neighbor
+          any: [{ kind: if_statement }, { kind: while_statement }, { kind: do_statement }]
+          field: condition
+    - inside: { stopBy: neighbor, kind: ternary_expression, field: condition }
+message: "A condition already converts to boolean; `!!` is redundant"
+fix: "$X"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```js
+if (user) {
+  greet();
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```jsx
+if (user) {
+  greet();
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```ts
+if (user) {
+  greet();
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+if (!!user) {
+  greet();
+}
+```
+
+#### Do
+
+```tsx
+if (user) {
+  greet();
+}
+```
+
+## Differences from the source
+
+`Boolean(x)` in a condition is not checked yet.

package/rules/js/no-fallthrough.md

@@ -0,0 +1,178 @@
+---
+id: js/no-fallthrough
+title: "A switch case does not fall through into the next by accident"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether the fall-through is intended needs the author"
+stability: preview
+ported_from: [eslint/no-fallthrough]
+since: 0.1.0
+---
+
+A `case` with statements ends in `break`, `return`, `throw` or `continue`, or says `// falls
+through` before the next case.
+
+**Why:** Falling through is easy to do by accident and hard to see in review.
+
+```codelaw
+native: js/no-fallthrough
+```
+
+## How to fix
+
+1. If the case should stop, end it with `break` (or `return`).
+2. If it should fall through, say so with a `// falls through` comment before the next case.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```js
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```js
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```jsx
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```jsx
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```ts
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```ts
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+switch (kind) {
+  case "a":
+    first();
+  case "b":
+    second();
+    break;
+}
+```
+
+#### Do
+
+```tsx
+switch (kind) {
+  case "a":
+    first();
+    break;
+  case "b":
+    second();
+    break;
+}
+```
+
+```tsx
+switch (kind) {
+  case "a":
+    first();
+  // falls through
+  case "b":
+    second();
+    break;
+}
+```