eslint-plugin-smarthr 3.3.2 → 3.5.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [3.5.0](https://github.com/kufu/tamatebako/compare/eslint-plugin-smarthr-v3.4.0...eslint-plugin-smarthr-v3.5.0) (2025-12-26)
+
+
+### Features
+
+* smarthr/best-practice-for-optional-chaining を追加 ([#979](https://github.com/kufu/tamatebako/issues/979)) ([ff18a55](https://github.com/kufu/tamatebako/commit/ff18a55970f026c2d828cf22f99e9969d90d7d82))
+* smarthr/best-practice-for-unnesessary-early-return を追加 ([#977](https://github.com/kufu/tamatebako/issues/977)) ([cd0b1a2](https://github.com/kufu/tamatebako/commit/cd0b1a205e82f01ce2be4fe43b69555d86ab5fd1))
+
+## [3.4.0](https://github.com/kufu/tamatebako/compare/eslint-plugin-smarthr-v3.3.2...eslint-plugin-smarthr-v3.4.0) (2025-12-24)
+
+
+### Features
+
+* best-practice-for-rest-parameters の残余引数の命名規則をrestもしくはxxxRestにすることを促すように修正 ([#973](https://github.com/kufu/tamatebako/issues/973)) ([3824818](https://github.com/kufu/tamatebako/commit/3824818a68d0ab6b2b2dc04ff5292f9d8be03d9b))
+
 ## [3.3.2](https://github.com/kufu/tamatebako/compare/eslint-plugin-smarthr-v3.3.1...eslint-plugin-smarthr-v3.3.2) (2025-12-23)
 
 

package/README.md

@@ -21,11 +21,13 @@
 - [best-practice-for-date](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-date)
 - [best-practice-for-layouts](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-layouts)
 - [best-practice-for-nested-attributes-array-index](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-nested-attributes-array-index)
+- [best-practice-for-optional-chaining](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-optional-chaining)
 - [best-practice-for-prohibit-import-smarthr-ui-local](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-prohibit-import-smarthr-ui-local)
 - [best-practice-for-remote-trigger-dialog](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-remote-trigger-dialog)
 - [best-practice-for-rest-parameters](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-rest-parameters)
 - [best-practice-for-tailwind-prohibit-root-margin](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-tailwind-prohibit-root-margin)
 - [best-practice-for-tailwind-variants](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-tailwind-variants)
+- [best-practice-for-unnesessary-early-return](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return)
 - [design-system-guideline-prohibit-double-icons](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/design-system-guideline-prohibit-double-icons)
 - [format-import-path](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/format-import-path)
 - [format-translate-component](https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/format-translate-component)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-smarthr",
-  "version": "3.3.2",
+  "version": "3.5.0",
   "author": "SmartHR",
   "license": "MIT",
   "description": "A sharable ESLint plugin for SmartHR",
@@ -26,7 +26,7 @@
     "json5": "^2.2.3"
   },
   "devDependencies": {
-    "typescript-eslint": "^8.50.0"
+    "typescript-eslint": "^8.50.1"
   },
   "peerDependencies": {
     "eslint": "^9"
@@ -37,5 +37,5 @@
     "eslintplugin",
     "smarthr"
   ],
-  "gitHead": "6b6b572bcc35d4b23cb20ef6b29bedf011e3a881"
+  "gitHead": "2709611af1e9178d321a0fbfc6564e2cbc454c72"
 }

package/rules/best-practice-for-optional-chaining/README.md

@@ -0,0 +1,75 @@
+# smarthr/best-practice-for-optional-chaining
+
+- optional chaining(xxx?.yyy記法)を使うことを促すルールです
+
+## rules
+
+```js
+{
+  rules: {
+    'smarthr/best-practice-for-optional-chaining': 'error', // 'warn', 'off'
+  },
+}
+```
+
+## ❌ Incorrect
+
+```jsx
+if (action) action()
+```
+
+```jsx
+if (obj.action) {
+  obj.action(hoge, fuga)
+}
+```
+
+
+## ✅ Correct
+
+```jsx
+action?.()
+```
+
+```jsx
+obj.action?.(hoge, fuga)
+```
+
+```jsx
+// 実行する関数と無関係の条件の場合は許容
+if (any) {
+  action()
+}
+```
+
+```jsx
+// 実行する関数の存在チェック以外が条件に含まれている場合は許容
+if (action && any) {
+  action()
+}
+```
+
+```jsx
+// if - else などifに他条件が連なる場合は許容
+if (action) {
+  action()
+} else {
+  ...
+}
+```
+
+```jsx
+// if内で関数呼び出し以外の処理が存在すれば許容
+if (action) {
+  return action()
+}
+```
+
+```jsx
+// else if内の場合は許容
+if (any) {
+  ...
+} else if (action) {
+  action()
+}
+```

package/rules/best-practice-for-optional-chaining/index.js

@@ -0,0 +1,40 @@
+const SCHEMA = []
+
+const REPLACABLE_CALLEE = `[consequent.expression.callee.type='Identifier']`
+const WITHOUT_BODY_IF_ID = `[test.type='Identifier']${REPLACABLE_CALLEE}`
+const WITH_BODY_IF_ID = WITHOUT_BODY_IF_ID.replace(REPLACABLE_CALLEE, "[consequent.body.length=1][consequent.body.0.expression.callee.type='Identifier']")
+const SELECTOR = `IfStatement[alternate=null]:not([parent.type='IfStatement']):matches(${WITHOUT_BODY_IF_ID},${WITHOUT_BODY_IF_ID.replaceAll("'Identifier'", "'MemberExpression'")},${WITH_BODY_IF_ID},${WITH_BODY_IF_ID.replaceAll("'Identifier'", "'MemberExpression'")})`
+
+
+/**
+ * @type {import('@typescript-eslint/utils').TSESLint.RuleModule<''>}
+ */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    schema: SCHEMA,
+  },
+  create(context) {
+    return {
+      [SELECTOR]: (node) => {
+        const expression = node.consequent.expression || node.consequent.body[0].expression
+        const calleName = context.sourceCode.getText(expression.callee)
+
+        if (context.sourceCode.getText(node.test) === calleName) {
+          context.report({
+            node,
+            message: `optional chaining(xxx?.yyyy記法)を利用してください
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-optional-chaining`,
+            fix: (fixer) => fixer.replaceText(
+              node,
+              context.sourceCode.getText(expression).replace(new RegExp(`^${calleName}\\(`), `${calleName}\?\.(`),
+            ),
+          })
+        }
+      },
+    }
+  },
+}
+module.exports.schema = SCHEMA
+

package/rules/best-practice-for-rest-parameters/README.md

@@ -1,17 +1,18 @@
 # smarthr/best-practice-for-rest-parameters
 
-- 残余引数(rest parameters)の命名規則を設定するルールです
+- 残余引数(rest parameters)の利用方法を設定するルールです
   - https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Functions/rest_parameters
 - 残余引数にはrestという名称を設定することを推奨します
   - よく利用される `props` などを利用するとエラーになります
     - コンポーネントが受け取れる属性を定義する際、多用される "Props" 型と勘違いされる可能性を減らすためです
     - 残余引数の時点でコンポーネントが受け取れる属性全てではないことが確定するためpropsの利用を禁止しています
     - `rest` という名称に揃えることで可読性を向上させることが出来ます
-- 残余引数以外でrestという名称と完全一致する設定することを禁止します
+  - restがすでに利用されており設定出来ない場合 `xxxRest` というフォーマットが利用出来ます
+- 残余引数以外でrest、もしくはxxxRestというフォーマットの名称を設定することを禁止します
   - restは rest parametersから命名されたjsのイディオムのため、残余引数以外の箇所で利用すると混乱を招くためです
-    - `xxxRest` のように他単語と組合されている場合はエラーになりません
 - 残余引数内の属性を直接参照することを禁止します
   - 例: `const hoge = rest.fuga`
+  - 例: `const { hoge } = rest`
   - この条件を守る場合、残余引数がそのスコープ内で関心が薄い引数の集まりになり、可読性が向上します
 
 ## rules
@@ -27,7 +28,7 @@
 ## ❌ Incorrect
 
 ```js
-// 残余引数にrest以外の名称が利用されているためNG
+// 残余引数にrest、xxxRest以外の名称が利用されているためNG
 const hoge = (a, b, ...props) => {
   // any
 }
@@ -37,15 +38,15 @@ const hoge = ({ a, b, ...props }) => {
   // any
 }
 
-// 残余引数ではない箇所でrestという文字列と完全一致する場合NG
-const hoge = (a, rest, b) => {
+// 残余引数ではない箇所で残余引数と勘違いしかねない命名がされているためNG
+const hoge = (a, anyRest, b) => {
   // any
 }
 // 引数以外の場合でも混乱するためNG
-const rest = { /* any */ }
+const hogeRest = { /* any */ }
 
 // 残余引数内の属性を参照しているためNG
-const Component = ({ a, b, ...rest }) => {
+const ComponentA = ({ a, b, ...rest }) => {
   ...
 
   if (rest.abc) {
@@ -54,6 +55,18 @@ const Component = ({ a, b, ...rest }) => {
 
   ...
 }
+const ComponentB = ({ a, b, ...rest }) => {
+  ...
+
+  // 残余引数を構造分解することもNG
+  const { abc } = rest
+
+  if (abc) {
+    return <Children {...rest} />
+  }
+
+  ...
+}
 ```
 
 ## ✅ Correct
@@ -64,6 +77,9 @@ const Component = ({ a, b, ...rest }) => {
 const hoge = (a, b, ...rest) => {
   // any
 }
+const fuga = ({ a, b, ...anyRest }) => {
+  // any
+}
 
 // 残余引数ではない場合、rest以外の名称を許容
 const hoge = (props) => {

package/rules/best-practice-for-rest-parameters/index.js

@@ -1,6 +1,7 @@
 const SCHEMA = []
 
-const MEMBER_EXPRESSION_REST_REGEX = /^rest\./
+const REST_REGEX = /(^r|R)est$/
+const MEMBER_EXPRESSION_REST_REGEX = /^(r|[a-zA-Z0-9_]+R)est\./
 const DETAIL_LINK = `
  - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-rest-parameters`
 
@@ -16,9 +17,9 @@ module.exports = {
     const actionNotRest = (node) => {
       context.report({
         node,
-        message: `残余引数以外に 'rest' という名称を利用しないでください${DETAIL_LINK}
+        message: `残余引数以外に ${REST_REGEX} とマッチする名称を利用しないでください${DETAIL_LINK}
  - 残余引数(rest parameters)と混同する可能性があるため別の名称に修正してください`,
-      });
+      })
     }
     const actionMemberExpressionName = (node) => {
       if (node.parent.type === 'MemberExpression') {
@@ -29,20 +30,32 @@ module.exports = {
         context.report({
           node,
           message: `残余引数内の属性を参照しないでください${DETAIL_LINK}`,
-        });
+        })
       }
     }
 
     return {
-      [`RestElement:not([argument.name='rest'])`]: (node) => {
+      [`ObjectPattern[properties.length=1]>RestElement`]: (node) => {
         context.report({
           node,
-          message: `残余引数には 'rest' という名称を指定してください${DETAIL_LINK}`,
-        });
+          message: `意味のない残余引数のため、単一の引数に変更してください${DETAIL_LINK}`,
+        })
+      },
+      [`RestElement:not([argument.name=${REST_REGEX}])`]: (node) => {
+        context.report({
+          node,
+          message: `残余引数には ${REST_REGEX} とマッチする名称を指定してください${DETAIL_LINK}`,
+        })
+      },
+      [`:not(:matches(RestElement,JSXSpreadAttribute,JSXSpreadAttribute>TSAsExpression,SpreadElement,SpreadElement>TSAsExpression,MemberExpression,VariableDeclarator,ArrayExpression,CallExpression,ObjectPattern>Property,ObjectExpression>Property))>Identifier[name=${REST_REGEX}]`]: actionNotRest,
+      [`:matches(VariableDeclarator[id.name=${REST_REGEX}],ObjectPattern>Property[value.name=${REST_REGEX}],ObjectExpression>Property[key.name=${REST_REGEX}])`]: actionNotRest,
+      [`MemberExpression[object.name=${REST_REGEX}]`]: actionMemberExpressionName,
+      [`VariableDeclarator[id.type='ObjectPattern'][init.name=${REST_REGEX}]`]: (node) => {
+        context.report({
+          node,
+          message: `残余引数内の属性を参照しないでください${DETAIL_LINK}`,
+        })
       },
-      [`:not(:matches(RestElement,JSXSpreadAttribute,JSXSpreadAttribute>TSAsExpression,SpreadElement,SpreadElement>TSAsExpression,MemberExpression,VariableDeclarator,ArrayExpression,CallExpression,ObjectPattern>Property,ObjectExpression>Property))>Identifier[name='rest']`]: actionNotRest,
-      [`:matches(VariableDeclarator[id.name='rest'],ObjectPattern>Property[value.name='rest'],ObjectExpression>Property[key.name='rest'])`]: actionNotRest,
-      [`MemberExpression[object.name='rest']`]: actionMemberExpressionName,
     }
   },
 }

package/rules/best-practice-for-unnesessary-early-return/README.md

@@ -0,0 +1,161 @@
+# smarthr/best-practice-for-unnesessary-early-return
+
+- 不必要な早期returnをチェックするルールです
+- 不要な早期returnとは **直後に実行される処理の条件を逆転している早期return** を指します
+
+```jsx
+// 不要な早期returnの例
+const anyAction = (a) => {
+  if (!a) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+- 上記の例の場合、実質 `otherActionを実行する条件だけが存在する` ため、実際にコードを読む際、条件を逆転させて考える余計なコストが発生します
+- 下記の様に早期returnを利用せず書くことを推奨します
+
+
+```jsx
+const anyAction = (a) => {
+  if (a) {
+    otherAction()
+  }
+}
+```
+
+- 上記のような条件に修正することで、本質的に実行したい処理の条件がわかりやすくなります
+- このルールは以下の条件すべてに合致する場合、NGにします
+  - 早期return以降にifやelse、switch, tryがない
+  - 早期returnの条件ブロック以降に変数宣言がない
+  - 早期returnの条件ブロック以降にreturnがない
+  - 早期returnが値を返していない
+
+## rules
+
+```js
+{
+  rules: {
+    'smarthr/best-practice-for-unnesessary-early-return': 'error', // 'warn', 'off'
+  },
+}
+```
+
+## ❌ Incorrect
+
+```jsx
+const anyAction = (a) => {
+  // otherActionの実行条件を逆転させているだけのためNG
+  if (!a) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+```jsx
+const anyAction = (a, b) => {
+  // 早期returnの条件内容自体は無関係にチェックするためNG
+  if (!a || !b) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+```jsx
+const anyAction = (a, b) => {
+  switch (a) {
+    ...
+  }
+
+  // 早期returnより前に条件などがあっても、条件が実質逆転しているためNG
+  if (!b) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+```jsx
+const anyAction = (a, b) => {
+  if (!a) {
+    return
+  }
+  // 早期returnが分割されているため、前述の早期returnの条件とまとめるべきなのでNG
+  if (!b) {
+    return
+  }
+
+  otherAction()
+}
+```
+
+## ✅ Correct
+
+```jsx
+const anyAction = (a) => {
+  if (a) {
+    otherAction()
+  }
+}
+```
+
+```jsx
+// 許容する早期returnの例
+const sample1 = (a) => {
+  if (a) {
+    // 早期returnで値を返しているため許容
+    return true
+  }
+  ...
+}
+
+const sample2 = (a) => {
+  if (!a) {
+    return
+  }
+
+  // 早期return後に変数宣言しているため許容
+  const caculated = calc(a)
+  ...
+}
+
+const sample3 = (a) => {
+  if (!a) {
+    return
+  }
+  // 早期returnの条件以外に条件が存在するため許容
+  else if (a === any) {
+    ...
+  }
+}
+
+const sample4 = (a, b) => {
+  if (!a) {
+    return
+  }
+
+  otherAction1(a)
+
+  // この場合も別条件のため許容
+  if (b === any) {
+    return
+  }
+  ...
+}
+
+const sample5 = (a, b) => {
+  if (!a) {
+    return
+  }
+
+  // 早期returnとは別のreturnが関数スコープのrootにあるため許容
+  return ...
+}
+```

package/rules/best-practice-for-unnesessary-early-return/index.js

@@ -0,0 +1,92 @@
+const SCHEMA = []
+
+const EARLY_RETURN_IF_STATEMENT = `:matches(ArrowFunctionExpression,FunctionExpression,FunctionDeclaration)>BlockStatement>IfStatement[alternate=null]:matches([consequent.type='ReturnStatement'],[consequent.body.length=1])>`
+const NULL_RETURN_STATEMENT = 'ReturnStatement[argument=null]'
+
+const FUNCTION_REGEX = /^(Arrow)?Function(Expression|Declaration)$/
+
+const searchFunction = (node) => FUNCTION_REGEX.test(node.type) ? node : searchFunction(node.parent)
+
+const getEarlyReturn = (b) => {
+  let ret = null
+  switch (b.consequent.type) {
+    case 'ReturnStatement':
+      ret = b.consequent
+
+      break
+    case 'BlockStatement':
+      if (b.consequent.body.length === 1 && b.consequent.body[0].type === 'ReturnStatement') {
+        ret = b.consequent.body[0]
+      }
+
+      break
+  }
+
+  return ret?.argument === null ? ret : null
+}
+
+const DETAIL_LINK = `
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return`
+
+/**
+ * @type {import('@typescript-eslint/utils').TSESLint.RuleModule<''>}
+ */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    schema: SCHEMA,
+  },
+  create(context) {
+    const action = (node) => {
+      const fn = searchFunction(node).body.body
+      // 0: 最初の早期returnを検索中
+      // 1: 最初の早期returnを発見、その後も連続して早期returnが存在する場合
+      // 2: 1の後、早期returnの連続が途切れた場合
+      let flg = 0
+
+      for (let i = 0; i < fn.length; i++) {
+        const b = fn[i]
+
+        if (!flg) {
+          if (b.type === 'IfStatement' && getEarlyReturn(b)) {
+            flg = 1
+          }
+
+          continue
+        }
+
+        switch (b.type) {
+          case 'VariableDeclaration':
+          case 'ReturnStatement':
+          case 'SwitchStatement':
+          case 'TryStatement':
+            return
+          case 'IfStatement':
+            if (flg === 1 && node === getEarlyReturn(b)) {
+              context.report({
+                node,
+                message: `早期returnのifが分割されています${DETAIL_LINK}
+ - 一つのifにまとめるよう、条件を調整してください`,
+              })
+            }
+            return
+        }
+
+        flg = 2
+      }
+
+      context.report({
+        node,
+        message: `後続の処理の逆の条件の早期returnのため修正してください。${DETAIL_LINK}
+ - 本質的に行いたい処理の条件とは逆がifに記述されているため、ロジックを確認する際条件を逆転させて考える余計な手間が発生しています
+ - 条件を逆転させたうえで後続の処理をifの内部に移動してください`,
+      })
+    }
+
+    return {
+      [`${EARLY_RETURN_IF_STATEMENT}BlockStatement>${NULL_RETURN_STATEMENT}`]: action,
+      [`${EARLY_RETURN_IF_STATEMENT}${NULL_RETURN_STATEMENT}`]: action,
+    }
+  },
+}
+module.exports.schema = SCHEMA

package/test/best-practice-for-optional-chaining.js

@@ -0,0 +1,48 @@
+const rule = require('../rules/best-practice-for-optional-chaining')
+const RuleTester = require('eslint').RuleTester
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+})
+
+const ERROR = `optional chaining(xxx?.yyyy記法)を利用してください
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-optional-chaining`
+
+ruleTester.run('best-practice-for-optional-chaining', rule, {
+  valid: [
+    { code: `action?.()` },
+    { code: `obj.action?.(hoge, fuga)` },
+    { code: `if (any) { action() }` },
+    { code: `if (action && any) { action() }` },
+    { code: `if (action) { action() } else { any() }` },
+    { code: `if (obj.hoge) obj.hoge.fuga.action()` },
+    { code: `() => { if (action) return action() }` },
+    { code: `if (any) {} else if (action) { action() }` },
+  ],
+  invalid: [
+    { code: `if (action) action()`, errors: [{ message: ERROR }], output: 'action?.()' },
+    { code: `if (obj.action) { obj.action(hoge, fuga) }`, errors: [{ message: ERROR }], output: 'obj.action?.(hoge, fuga)' },
+    { code: `if (obj.hoge.fuga.action) obj.hoge.fuga.action()`, errors: [{ message: ERROR }], output: 'obj.hoge.fuga.action?.()' },
+    { code: `
+      if (obj.hoge.fuga.action) {
+        obj.hoge.fuga.action(
+          a,
+          b,
+          c
+        )
+      }
+    `, errors: [{ message: ERROR }], output: `
+      obj.hoge.fuga.action?.(
+          a,
+          b,
+          c
+        )
+    ` },
+  ],
+})

package/test/best-practice-for-rest-parameters.js

@@ -13,37 +13,40 @@ const ruleTester = new RuleTester({
 
 const DETAIL_LINK = `
  - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-rest-parameters`
-const ERROR_REST_NAME = `残余引数には 'rest' という名称を指定してください${DETAIL_LINK}`
-const ERROR_NOT_REST_NAME = `残余引数以外に 'rest' という名称を利用しないでください${DETAIL_LINK}
+const ERROR_REST_NAME = `残余引数には /(^r|R)est$/ とマッチする名称を指定してください${DETAIL_LINK}`
+const ERROR_NOT_REST_NAME = `残余引数以外に /(^r|R)est$/ とマッチする名称を利用しないでください${DETAIL_LINK}
  - 残余引数(rest parameters)と混同する可能性があるため別の名称に修正してください`
 const ERROR_REST_CHILD_REF = `残余引数内の属性を参照しないでください${DETAIL_LINK}`
 
 ruleTester.run('best-practice-for-rest-parameters', rule, {
   valid: [
+    { code: `const hoge = (...rest) => {}` },
     { code: `const hoge = (a, b, ...rest) => {}` },
-    { code: `const hoge = ({ a, b, ...rest }) => {}` },
+    { code: `const hoge = ({ a, b, ...anyRest }) => {}` },
     { code: `const hoge = (props) => {}` },
     { code: `const props = {}` },
-    { code: `const hogeRest = {}` },
     { code: `const hoge = { fuga: rest }` },
-    { code: `const hoge = rest` },
+    { code: `const hoge = hogeRest` },
     { code: `const hoge = hoge.rest.fuga` },
-    { code: `const hoge = { ...rest }` },
+    { code: `const hoge = { ...anyRest }` },
     { code: `const hoge = [rest]` },
-    { code: `hoge(rest)` },
+    { code: `hoge(fugaRest)` },
     { code: `<Any {...rest} />` },
   ],
   invalid: [
-    { code: `const hoge = (a, b, ...props) => {}`, errors: [ { message: ERROR_REST_NAME } ] },
-    { code: `const hoge = ({ a, b, ...props }) => {}`, errors: [ { message: ERROR_REST_NAME } ] },
+    { code: `const hoge = ({ ...rest }) => {}`, errors: [ { message: `意味のない残余引数のため、単一の引数に変更してください${DETAIL_LINK}` } ] },
+    { code: `const hoge = (a, b, ...any) => {}`, errors: [ { message: ERROR_REST_NAME } ] },
+    { code: `const hoge = ({ a, b, ...restHoge }) => {}`, errors: [ { message: ERROR_REST_NAME } ] },
     { code: `const hoge = (rest) => {}`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
+    { code: `const hogeRest = {}`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
     { code: `const hoge = (a, b, rest) => {}`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
-    { code: `const hoge = ({ a: rest, b }) => {}`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
+    { code: `const hoge = ({ a: anyRest, b }) => {}`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
     { code: `const rest = {}`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
-    { code: `const hoge = { rest }`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
+    { code: `const hoge = { hogeRest }`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
     { code: `const hoge = { rest: fuga }`, errors: [ { message: ERROR_NOT_REST_NAME } ] },
     { code: `const hoge = rest.hoge`, errors: [ { message: ERROR_REST_CHILD_REF } ] },
-    { code: `const hoge = rest.hoge.fuga`, errors: [ { message: ERROR_REST_CHILD_REF } ] },
+    { code: `const hoge = anyRest.hoge.fuga`, errors: [ { message: ERROR_REST_CHILD_REF } ] },
+    { code: `const { any } = rest`, errors: [ { message: ERROR_REST_CHILD_REF } ] },
   ]
 })
 

package/test/best-practice-for-unnesessary-early-return.js

@@ -0,0 +1,189 @@
+const rule = require('../rules/best-practice-for-unnesessary-early-return')
+const RuleTester = require('eslint').RuleTester
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+})
+
+const UNNESESSARY_EARLY_RETURN_ERROR = `後続の処理の逆の条件の早期returnのため修正してください。
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return
+ - 本質的に行いたい処理の条件とは逆がifに記述されているため、ロジックを確認する際条件を逆転させて考える余計な手間が発生しています
+ - 条件を逆転させたうえで後続の処理をifの内部に移動してください`
+const SPLIT_EARLY_RETURN_ERROR = `早期returnのifが分割されています
+ - 詳細: https://github.com/kufu/tamatebako/tree/master/packages/eslint-plugin-smarthr/rules/best-practice-for-unnesessary-early-return
+ - 一つのifにまとめるよう、条件を調整してください`
+
+ruleTester.run('best-practice-for-unnesessary-early-return', rule, {
+  valid: [
+    { code: `
+      const anyAction = (a) => {
+        if (a) {
+          otherAction()
+        }
+      }
+    ` },
+    { code: `
+      const sample2 = (a) => {
+        if (!a) return
+
+        const caculated = calc(a)
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        } else {
+        }
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        } else if (any) {
+        }
+      }
+    ` },
+    { code: `
+      const sample4 = (a, b) => {
+        if (!a) {
+          return
+        }
+
+        otherAction1(a)
+
+        if (b === any) {
+          return
+        }
+
+        otherAction2(b)
+      }
+    ` },
+    { code: `
+      const sample4 = (a, b) => {
+        if (!a) {
+          return
+        }
+
+        switch(a) {
+          case 'hoge':
+            break
+        }
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          otherAction1()
+          return
+        }
+
+        otherAction2()
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        }
+
+        return otherAction2()
+      }
+    ` },
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        }
+
+        try {
+          otherAction()
+        } catch {
+        }
+      }
+    ` },
+  ],
+  invalid: [
+    { code: `
+      const anyAction = (a) => {
+        if (!a) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a) => {
+        const hoge = any
+
+        if (!a) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        if (!a || !b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        switch (a) {
+          case 'hoge':
+            break
+        }
+
+        if (!b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        // 早期returnより前に非早期returnのif,switchがある場合
+        if (a && b) {
+          return 'hoge'
+        }
+
+        // 早期return後にswitchがある場合強制終了されるが
+        // このswitchは早期return前のため後続でエラーになる
+        switch (a) {
+          case 'hoge':
+            break
+        }
+
+        if (!b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ { message: UNNESESSARY_EARLY_RETURN_ERROR } ] },
+    { code: `
+      const anyAction = (a, b) => {
+        if (!a) return
+        if (!b) {
+          return
+        }
+
+        otherAction()
+      }
+    `, errors: [ SPLIT_EARLY_RETURN_ERROR ] },
+  ]
+})