@codelaw/rules-js 0.0.0-stage → 0.2.0

package/rules/js/no-var.md

@@ -0,0 +1,76 @@
+---
+id: js/no-var
+title: "let or const instead of var"
+languages: [javascript, jsx, typescript, tsx]
+fix: suggest
+fix_reason: "`let` is block-scoped, so a `var` used outside its block or before its declaration changes meaning"
+stability: preview
+ported_from: [eslint/no-var]
+since: 0.1.0
+---
+
+Variables are declared with `let` or `const`, never `var`.
+
+**Why:** `var` is function-scoped and hoisted, which causes bugs `let` and `const` rule out.
+
+```codelaw
+native: js/no-var
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+var total = 0;
+```
+
+#### Do
+
+```js
+let total = 0;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+var total = 0;
+```
+
+#### Do
+
+```jsx
+let total = 0;
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+var total = 0;
+```
+
+#### Do
+
+```ts
+let total = 0;
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+var total = 0;
+```
+
+#### Do
+
+```tsx
+let total = 0;
+```

package/rules/js/no-with.md

@@ -0,0 +1,60 @@
+---
+id: js/no-with
+title: "No with statements"
+languages: [javascript, jsx]
+fix: manual
+fix_reason: "each name inside needs to be qualified by hand"
+stability: preview
+ported_from: [eslint/no-with]
+since: 0.1.0
+---
+
+Code doesn't use `with`.
+
+**Why:** `with` makes it impossible to tell which names are properties and which are variables, and
+is an error in strict code.
+
+```codelaw
+match:
+  kind: with_statement
+message: "`with` makes every name inside it ambiguous"
+```
+
+## How to fix
+
+1. Replace each property used inside `with` by `object.property`.
+2. Remove the `with`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+with (Math) {
+  area = PI * r * r;
+}
+```
+
+#### Do
+
+```js
+area = Math.PI * r * r;
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+with (Math) {
+  area = PI * r * r;
+}
+```
+
+#### Do
+
+```jsx
+area = Math.PI * r * r;
+```

package/rules/js/prefer-const.md

@@ -0,0 +1,83 @@
+---
+id: js/prefer-const
+title: "const for variables that are never reassigned"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/prefer-const]
+since: 0.1.0
+---
+
+A `let` whose names all get their value in the declaration and are never reassigned is a `const`.
+
+**Why:** `const` tells the reader the binding won't change, and the engine enforces it.
+
+```codelaw
+native: js/prefer-const
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```js
+const limit = 10;
+use(limit);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```jsx
+const limit = 10;
+use(limit);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```ts
+const limit = 10;
+use(limit);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+let limit = 10;
+use(limit);
+```
+
+#### Do
+
+```tsx
+const limit = 10;
+use(limit);
+```

package/rules/js/prefer-rest-params.md

@@ -0,0 +1,103 @@
+---
+id: js/prefer-rest-params
+title: "Rest parameters instead of arguments"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "the parameter list has to be rewritten by hand"
+stability: preview
+ported_from: [eslint/prefer-rest-params]
+since: 0.1.0
+---
+
+Functions take a rest parameter `...args` instead of reading `arguments`.
+
+**Why:** `arguments` is not a real array, isn't available in arrow functions, and hides how many
+arguments a function takes.
+
+```codelaw
+match:
+  kind: identifier
+  regex: ^arguments$
+where:
+  $$MATCH: builtin
+message: "Use a rest parameter (`...args`) instead of `arguments`"
+```
+
+## How to fix
+
+1. Add a rest parameter `...args` to the function.
+2. Replace each use of `arguments` with it.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function sum() {
+  return Array.from(arguments).reduce(add, 0);
+}
+```
+
+#### Do
+
+```js
+function sum(...numbers) {
+  return numbers.reduce(add, 0);
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function sum() {
+  return Array.from(arguments).reduce(add, 0);
+}
+```
+
+#### Do
+
+```jsx
+function sum(...numbers) {
+  return numbers.reduce(add, 0);
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function sum() {
+  return Array.from(arguments).reduce(add, 0);
+}
+```
+
+#### Do
+
+```ts
+function sum(...numbers) {
+  return numbers.reduce(add, 0);
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function sum() {
+  return Array.from(arguments).reduce(add, 0);
+}
+```
+
+#### Do
+
+```tsx
+function sum(...numbers) {
+  return numbers.reduce(add, 0);
+}
+```

package/rules/js/prefer-spread.md

@@ -0,0 +1,95 @@
+---
+id: js/prefer-spread
+title: "Spread instead of .apply()"
+languages: [javascript, jsx, typescript, tsx]
+fix: auto
+stability: preview
+ported_from: [eslint/prefer-spread]
+since: 0.1.0
+---
+
+A function is called with spread arguments, `f(...args)`, instead of `f.apply(null, args)`.
+
+**Why:** Spread says the same thing more directly, and doesn't need a `this` value.
+
+```codelaw
+match:
+  any:
+    - pattern: $F.apply(null, $ARGS)
+    - pattern: $F.apply(undefined, $ARGS)
+constraints:
+  F: { kind: identifier }
+message: "Use spread: `$F(...$ARGS)`"
+fix: "$F(...$ARGS)"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+const max = Math.max.apply(null, values);
+const min = least.apply(null, values);
+```
+
+#### Do
+
+```js
+const max = Math.max.apply(null, values);
+const min = least(...values);
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+const max = Math.max.apply(null, values);
+const min = least.apply(null, values);
+```
+
+#### Do
+
+```jsx
+const max = Math.max.apply(null, values);
+const min = least(...values);
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+const max = Math.max.apply(null, values);
+const min = least.apply(null, values);
+```
+
+#### Do
+
+```ts
+const max = Math.max.apply(null, values);
+const min = least(...values);
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+const max = Math.max.apply(null, values);
+const min = least.apply(null, values);
+```
+
+#### Do
+
+```tsx
+const max = Math.max.apply(null, values);
+const min = least(...values);
+```
+
+## Differences from the source
+
+Only `f.apply(null, args)` and `f.apply(undefined, args)` on a plain function name are checked;
+method calls are left alone.

package/rules/js/preserve-caught-error.md

@@ -0,0 +1,122 @@
+---
+id: js/preserve-caught-error
+title: "A rethrown error keeps the caught one as its cause"
+languages: [javascript, jsx, typescript, tsx]
+fix: suggest
+fix_reason: "the new error class must accept an options argument"
+stability: preview
+ported_from: [eslint/preserve-caught-error]
+since: 0.1.0
+---
+
+A built-in error (`Error`, `TypeError` and the rest) thrown from a `catch` block passes the caught
+error as `{ cause }`.
+
+**Why:** Without the cause, the original error and its stack are lost.
+
+```codelaw
+match:
+  pattern: throw new $C($MSG);
+  inside:
+    kind: catch_clause
+    has: { field: parameter, pattern: $E }
+    stopBy:
+      any: [{kind: function_declaration}, {kind: function_expression}, {kind: arrow_function}, {kind: method_definition}, {kind: generator_function_declaration}, {kind: generator_function}]
+constraints:
+  C: { regex: ^(Error|TypeError|RangeError|ReferenceError|SyntaxError|URIError|EvalError)$ }
+  MSG: { not: { kind: object } }
+where:
+  $C: builtin
+message: "Pass the caught error as the cause: `new $C($MSG, { cause: $E })`"
+fix: "throw new $C($MSG, { cause: $E });"
+```
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed");
+}
+```
+
+#### Do
+
+```js
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed", { cause: err });
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed");
+}
+```
+
+#### Do
+
+```jsx
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed", { cause: err });
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed");
+}
+```
+
+#### Do
+
+```ts
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed", { cause: err });
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed");
+}
+```
+
+#### Do
+
+```tsx
+try {
+  load();
+} catch (err) {
+  throw new Error("Load failed", { cause: err });
+}
+```

package/rules/js/require-yield.md

@@ -0,0 +1,107 @@
+---
+id: js/require-yield
+title: "A generator function yields"
+languages: [javascript, jsx, typescript, tsx]
+fix: manual
+fix_reason: "whether to yield or to drop the `*` needs the author"
+stability: preview
+ported_from: [eslint/require-yield]
+since: 0.1.0
+---
+
+A non-empty generator function contains at least one `yield`.
+
+**Why:** A generator without `yield` is either unfinished or should be a plain function.
+
+```codelaw
+match:
+  any:
+    - kind: generator_function_declaration
+    - kind: generator_function
+  not:
+    any:
+      - has: { field: body, regex: '^\{\s*\}$' }
+      - has:
+          kind: yield_expression
+          stopBy:
+            any: [{kind: function_declaration}, {kind: function_expression}, {kind: arrow_function}, {kind: method_definition}, {kind: generator_function_declaration}, {kind: generator_function}]
+message: "A generator that never yields is a plain function"
+```
+
+## How to fix
+
+1. Add the `yield` the generator was meant to have, or remove the `*`.
+
+## Examples
+
+### JavaScript
+
+#### Don't
+
+```js
+function* ids() {
+  return 1;
+}
+```
+
+#### Do
+
+```js
+function* ids() {
+  yield 1;
+}
+```
+
+### JSX
+
+#### Don't
+
+```jsx
+function* ids() {
+  return 1;
+}
+```
+
+#### Do
+
+```jsx
+function* ids() {
+  yield 1;
+}
+```
+
+### TypeScript
+
+#### Don't
+
+```ts
+function* ids() {
+  return 1;
+}
+```
+
+#### Do
+
+```ts
+function* ids() {
+  yield 1;
+}
+```
+
+### TSX
+
+#### Don't
+
+```tsx
+function* ids() {
+  return 1;
+}
+```
+
+#### Do
+
+```tsx
+function* ids() {
+  yield 1;
+}
+```