eslint-plugin-jsdoc 50.6.16 → 50.7.0

package/dist/utils/hasReturnValue.cjs

@@ -26,7 +26,9 @@ const isNewPromiseExpression = node => {
 const isVoidPromise = node => {
   var _node$typeArguments, _node$typeParameters;
   return /** @type {import('@typescript-eslint/types').TSESTree.TSTypeReference} */(node === null || node === void 0 || (_node$typeArguments = node.typeArguments) === null || _node$typeArguments === void 0 || (_node$typeArguments = _node$typeArguments.params) === null || _node$typeArguments === void 0 || (_node$typeArguments = _node$typeArguments[0]) === null || _node$typeArguments === void 0 ? void 0 : _node$typeArguments.type) === 'TSVoidKeyword'
-  /* c8 ignore next 4 */ || /** @type {import('@typescript-eslint/types').TSESTree.TSTypeReference} */(node
+  /* c8 ignore next 5 */
+  // eslint-disable-next-line @stylistic/operator-linebreak -- c8
+  || /** @type {import('@typescript-eslint/types').TSESTree.TSTypeReference} */(node
   // @ts-expect-error Ok
   === null || node
   // @ts-expect-error Ok
@@ -34,7 +36,7 @@ const isVoidPromise = node => {
   // @ts-expect-error Ok
   .typeParameters) === null || _node$typeParameters === void 0 || (_node$typeParameters = _node$typeParameters.params) === null || _node$typeParameters === void 0 || (_node$typeParameters = _node$typeParameters[0]) === null || _node$typeParameters === void 0 ? void 0 : _node$typeParameters.type) === 'TSVoidKeyword';
 };
-const undefinedKeywords = new Set(['TSVoidKeyword', 'TSUndefinedKeyword', 'TSNeverKeyword']);
+const undefinedKeywords = new Set(['TSNeverKeyword', 'TSUndefinedKeyword', 'TSVoidKeyword']);
 
 /**
  * Checks if a node has a return statement. Void return does not count.
@@ -49,19 +51,9 @@ const hasReturnValue = (node, throwOnNullReturn, promFilter) => {
     return false;
   }
   switch (node.type) {
-    case 'TSDeclareFunction':
-    case 'TSFunctionType':
-    case 'TSMethodSignature':
-      {
-        var _node$returnType;
-        const type = node === null || node === void 0 || (_node$returnType = node.returnType) === null || _node$returnType === void 0 || (_node$returnType = _node$returnType.typeAnnotation) === null || _node$returnType === void 0 ? void 0 : _node$returnType.type;
-        return type && !undefinedKeywords.has(type);
-      }
-    case 'MethodDefinition':
-      return hasReturnValue(node.value, throwOnNullReturn, promFilter);
-    case 'FunctionExpression':
-    case 'FunctionDeclaration':
     case 'ArrowFunctionExpression':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
       {
         return 'expression' in node && node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) || hasReturnValue(node.body, throwOnNullReturn, promFilter);
       }
@@ -71,12 +63,12 @@ const hasReturnValue = (node, throwOnNullReturn, promFilter) => {
           return bodyNode.type !== 'FunctionDeclaration' && hasReturnValue(bodyNode, throwOnNullReturn, promFilter);
         });
       }
-    case 'LabeledStatement':
-    case 'WhileStatement':
     case 'DoWhileStatement':
-    case 'ForStatement':
     case 'ForInStatement':
     case 'ForOfStatement':
+    case 'ForStatement':
+    case 'LabeledStatement':
+    case 'WhileStatement':
     case 'WithStatement':
       {
         return hasReturnValue(node.body, throwOnNullReturn, promFilter);
@@ -85,18 +77,8 @@ const hasReturnValue = (node, throwOnNullReturn, promFilter) => {
       {
         return hasReturnValue(node.consequent, throwOnNullReturn, promFilter) || hasReturnValue(node.alternate, throwOnNullReturn, promFilter);
       }
-    case 'TryStatement':
-      {
-        return hasReturnValue(node.block, throwOnNullReturn, promFilter) || hasReturnValue(node.handler && node.handler.body, throwOnNullReturn, promFilter) || hasReturnValue(node.finalizer, throwOnNullReturn, promFilter);
-      }
-    case 'SwitchStatement':
-      {
-        return node.cases.some(someCase => {
-          return someCase.consequent.some(nde => {
-            return hasReturnValue(nde, throwOnNullReturn, promFilter);
-          });
-        });
-      }
+    case 'MethodDefinition':
+      return hasReturnValue(node.value, throwOnNullReturn, promFilter);
     case 'ReturnStatement':
       {
         // void return does not count.
@@ -113,6 +95,26 @@ const hasReturnValue = (node, throwOnNullReturn, promFilter) => {
         }
         return true;
       }
+    case 'SwitchStatement':
+      {
+        return node.cases.some(someCase => {
+          return someCase.consequent.some(nde => {
+            return hasReturnValue(nde, throwOnNullReturn, promFilter);
+          });
+        });
+      }
+    case 'TryStatement':
+      {
+        return hasReturnValue(node.block, throwOnNullReturn, promFilter) || hasReturnValue(node.handler && node.handler.body, throwOnNullReturn, promFilter) || hasReturnValue(node.finalizer, throwOnNullReturn, promFilter);
+      }
+    case 'TSDeclareFunction':
+    case 'TSFunctionType':
+    case 'TSMethodSignature':
+      {
+        var _node$returnType;
+        const type = node === null || node === void 0 || (_node$returnType = node.returnType) === null || _node$returnType === void 0 || (_node$returnType = _node$returnType.typeAnnotation) === null || _node$returnType === void 0 ? void 0 : _node$returnType.type;
+        return type && !undefinedKeywords.has(type);
+      }
     default:
       {
         return false;
@@ -133,20 +135,11 @@ const allBrancheshaveReturnValues = (node, promFilter) => {
     return false;
   }
   switch (node.type) {
-    case 'TSDeclareFunction':
-    case 'TSFunctionType':
-    case 'TSMethodSignature':
-      {
-        var _node$returnType2;
-        const type = node === null || node === void 0 || (_node$returnType2 = node.returnType) === null || _node$returnType2 === void 0 || (_node$returnType2 = _node$returnType2.typeAnnotation) === null || _node$returnType2 === void 0 ? void 0 : _node$returnType2.type;
-        return type && !undefinedKeywords.has(type);
-      }
-
     // case 'MethodDefinition':
     //   return allBrancheshaveReturnValues(node.value, promFilter);
-    case 'FunctionExpression':
-    case 'FunctionDeclaration':
     case 'ArrowFunctionExpression':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
       {
         return 'expression' in node && node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) || allBrancheshaveReturnValues(node.body, promFilter) || /** @type {import('@typescript-eslint/types').TSESTree.BlockStatement} */
         node.body.body.some(nde => {
@@ -158,8 +151,8 @@ const allBrancheshaveReturnValues = (node, promFilter) => {
         const lastBodyNode = node.body.slice(-1)[0];
         return allBrancheshaveReturnValues(lastBodyNode, promFilter);
       }
-    case 'WhileStatement':
     case 'DoWhileStatement':
+    case 'WhileStatement':
       if (
       /**
        * @type {import('@typescript-eslint/types').TSESTree.Literal}
@@ -177,9 +170,9 @@ const allBrancheshaveReturnValues = (node, promFilter) => {
         //   is needed to provide a return
         return hasReturnValue(node.body, false, promFilter);
       }
-    case 'LabeledStatement':
     case 'ForInStatement':
     case 'ForOfStatement':
+    case 'LabeledStatement':
     case 'WithStatement':
       {
         return allBrancheshaveReturnValues(node.body, promFilter);
@@ -188,6 +181,31 @@ const allBrancheshaveReturnValues = (node, promFilter) => {
       {
         return allBrancheshaveReturnValues(node.consequent, promFilter) && allBrancheshaveReturnValues(node.alternate, promFilter);
       }
+    case 'ReturnStatement':
+      {
+        // void return does not count.
+        if (node.argument === null) {
+          return false;
+        }
+        if (promFilter && isNewPromiseExpression(node.argument)) {
+          // Let caller decide how to filter, but this is, at the least,
+          //   a return of sorts and truthy
+          return promFilter(node.argument);
+        }
+        return true;
+      }
+    case 'SwitchStatement':
+      {
+        return /** @type {import('@typescript-eslint/types').TSESTree.SwitchStatement} */node.cases.every(someCase => {
+          return !someCase.consequent.some(consNode => {
+            return consNode.type === 'BreakStatement' || consNode.type === 'ReturnStatement' && consNode.argument === null;
+          });
+        });
+      }
+    case 'ThrowStatement':
+      {
+        return true;
+      }
     case 'TryStatement':
       {
         // If `finally` returns, all return
@@ -197,10 +215,11 @@ const allBrancheshaveReturnValues = (node, promFilter) => {
           try {
             hasReturnValue(node.finalizer, true, promFilter);
           } catch (error) {
-            if ( /** @type {Error} */error.message === 'Null return') {
+            if (/** @type {Error} */error.message === 'Null return') {
               return false;
             }
-            /* c8 ignore next 2 */
+            /* c8 ignore next 3 */
+            // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
             throw error;
           }
 
@@ -208,30 +227,13 @@ const allBrancheshaveReturnValues = (node, promFilter) => {
           return true;
         })());
       }
-    case 'SwitchStatement':
-      {
-        return /** @type {import('@typescript-eslint/types').TSESTree.SwitchStatement} */node.cases.every(someCase => {
-          return !someCase.consequent.some(consNode => {
-            return consNode.type === 'BreakStatement' || consNode.type === 'ReturnStatement' && consNode.argument === null;
-          });
-        });
-      }
-    case 'ThrowStatement':
-      {
-        return true;
-      }
-    case 'ReturnStatement':
+    case 'TSDeclareFunction':
+    case 'TSFunctionType':
+    case 'TSMethodSignature':
       {
-        // void return does not count.
-        if (node.argument === null) {
-          return false;
-        }
-        if (promFilter && isNewPromiseExpression(node.argument)) {
-          // Let caller decide how to filter, but this is, at the least,
-          //   a return of sorts and truthy
-          return promFilter(node.argument);
-        }
-        return true;
+        var _node$returnType2;
+        const type = node === null || node === void 0 || (_node$returnType2 = node.returnType) === null || _node$returnType2 === void 0 || (_node$returnType2 = _node$returnType2.typeAnnotation) === null || _node$returnType2 === void 0 ? void 0 : _node$returnType2.type;
+        return type && !undefinedKeywords.has(type);
       }
     default:
       {
@@ -266,90 +268,59 @@ const hasNonEmptyResolverCall = (node, resolverName) => {
 
   // Arrow function without block
   switch (node.type) {
-    /* c8 ignore next 2 -- In Babel? */
-    // @ts-expect-error Babel?
-    case 'OptionalCallExpression':
-    case 'CallExpression':
-      return /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */node.callee.name === resolverName && (
-      // Implicit or explicit undefined
-      node.arguments.length > 1 || node.arguments[0] !== undefined) || node.arguments.some(nde => {
-        // Being passed in to another function (which might invoke it)
-        return nde.type === 'Identifier' && nde.name === resolverName ||
-        // Handle nested items
-        hasNonEmptyResolverCall(nde, resolverName);
-      });
-    case 'ChainExpression':
-    case 'Decorator':
-    case 'ExpressionStatement':
-      return hasNonEmptyResolverCall(node.expression, resolverName);
-    case 'ClassBody':
-    case 'BlockStatement':
-      return node.body.some(bodyNode => {
-        return hasNonEmptyResolverCall(bodyNode, resolverName);
+    case 'ArrayExpression':
+    case 'ArrayPattern':
+      return node.elements.some(element => {
+        return hasNonEmptyResolverCall(element, resolverName);
       });
-    case 'FunctionExpression':
-    case 'FunctionDeclaration':
     case 'ArrowFunctionExpression':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
       {
         var _node$params$;
         // Shadowing
-        if ( /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */((_node$params$ = node.params[0]) === null || _node$params$ === void 0 ? void 0 : _node$params$.name) === resolverName) {
+        if (/** @type {import('@typescript-eslint/types').TSESTree.Identifier} */((_node$params$ = node.params[0]) === null || _node$params$ === void 0 ? void 0 : _node$params$.name) === resolverName) {
           return false;
         }
         return hasNonEmptyResolverCall(node.body, resolverName);
       }
-    case 'LabeledStatement':
-    case 'WhileStatement':
-    case 'DoWhileStatement':
-    case 'ForStatement':
-    case 'ForInStatement':
-    case 'ForOfStatement':
-    case 'WithStatement':
-      {
-        return hasNonEmptyResolverCall(node.body, resolverName);
-      }
-    case 'ConditionalExpression':
-    case 'IfStatement':
-      {
-        return hasNonEmptyResolverCall(node.test, resolverName) || hasNonEmptyResolverCall(node.consequent, resolverName) || hasNonEmptyResolverCall(node.alternate, resolverName);
-      }
-    case 'TryStatement':
-      {
-        return hasNonEmptyResolverCall(node.block, resolverName) || hasNonEmptyResolverCall(node.handler && node.handler.body, resolverName) || hasNonEmptyResolverCall(node.finalizer, resolverName);
-      }
-    case 'SwitchStatement':
-      {
-        return node.cases.some(someCase => {
-          return someCase.consequent.some(nde => {
-            return hasNonEmptyResolverCall(nde, resolverName);
-          });
-        });
-      }
-    case 'ArrayPattern':
-    case 'ArrayExpression':
-      return node.elements.some(element => {
-        return hasNonEmptyResolverCall(element, resolverName);
-      });
-    case 'AssignmentPattern':
-      return hasNonEmptyResolverCall(node.right, resolverName);
     case 'AssignmentExpression':
     case 'BinaryExpression':
     case 'LogicalExpression':
       {
         return hasNonEmptyResolverCall(node.left, resolverName) || hasNonEmptyResolverCall(node.right, resolverName);
       }
-
-    // Comma
-    case 'SequenceExpression':
-    case 'TemplateLiteral':
-      return node.expressions.some(subExpression => {
-        return hasNonEmptyResolverCall(subExpression, resolverName);
+    case 'AssignmentPattern':
+      return hasNonEmptyResolverCall(node.right, resolverName);
+    case 'AwaitExpression':
+    case 'SpreadElement':
+    case 'UnaryExpression':
+    case 'YieldExpression':
+      return hasNonEmptyResolverCall(node.argument, resolverName);
+    case 'BlockStatement':
+    case 'ClassBody':
+      return node.body.some(bodyNode => {
+        return hasNonEmptyResolverCall(bodyNode, resolverName);
       });
-    case 'ObjectPattern':
-    case 'ObjectExpression':
-      return node.properties.some(property => {
-        return hasNonEmptyResolverCall(property, resolverName);
+    /* c8 ignore next 2 -- In Babel? */
+    case 'CallExpression':
+    // @ts-expect-error Babel?
+    case 'OptionalCallExpression':
+      return /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */node.callee.name === resolverName && (
+      // Implicit or explicit undefined
+      node.arguments.length > 1 || node.arguments[0] !== undefined) || node.arguments.some(nde => {
+        // Being passed in to another function (which might invoke it)
+        return nde.type === 'Identifier' && nde.name === resolverName ||
+        // Handle nested items
+        hasNonEmptyResolverCall(nde, resolverName);
       });
+    case 'ChainExpression':
+    case 'Decorator':
+    case 'ExpressionStatement':
+      return hasNonEmptyResolverCall(node.expression, resolverName);
+    case 'ClassDeclaration':
+    case 'ClassExpression':
+      return hasNonEmptyResolverCall(node.body, resolverName);
     /* c8 ignore next 2 -- In Babel? */
     // @ts-expect-error Babel?
     case 'ClassMethod':
@@ -360,16 +331,46 @@ const hasNonEmptyResolverCall = (node, resolverName) => {
 
     /* c8 ignore next 2 -- In Babel? */
     // @ts-expect-error Babel?
-    case 'ObjectProperty':
-    /* eslint-disable no-fallthrough */
-    /* c8 ignore next -- In Babel? */
-    case 'PropertyDefinition':
+    case 'ClassProperty':
     /* c8 ignore next 2 -- In Babel? */
     // @ts-expect-error Babel?
-    case 'ClassProperty':
+    case 'ObjectProperty':
     case 'Property':
-      /* eslint-enable no-fallthrough */
+    case 'PropertyDefinition':
       return node.computed && hasNonEmptyResolverCall(node.key, resolverName) || hasNonEmptyResolverCall(node.value, resolverName);
+    case 'ConditionalExpression':
+    case 'IfStatement':
+      {
+        return hasNonEmptyResolverCall(node.test, resolverName) || hasNonEmptyResolverCall(node.consequent, resolverName) || hasNonEmptyResolverCall(node.alternate, resolverName);
+      }
+    case 'DoWhileStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'ForStatement':
+    case 'LabeledStatement':
+    case 'WhileStatement':
+    case 'WithStatement':
+      {
+        return hasNonEmptyResolverCall(node.body, resolverName);
+      }
+
+    /* c8 ignore next 2 -- In Babel? */
+    // @ts-expect-error Babel?
+    case 'Import':
+    case 'ImportExpression':
+      return hasNonEmptyResolverCall(node.source, resolverName);
+    // ?.
+    /* c8 ignore next 2 -- In Babel? */
+    case 'MemberExpression':
+
+    // @ts-expect-error Babel?
+    case 'OptionalMemberExpression':
+      return hasNonEmptyResolverCall(node.object, resolverName) || hasNonEmptyResolverCall(node.property, resolverName);
+    case 'ObjectExpression':
+    case 'ObjectPattern':
+      return node.properties.some(property => {
+        return hasNonEmptyResolverCall(property, resolverName);
+      });
     /* c8 ignore next 2 -- In Babel? */
     // @ts-expect-error Babel?
     case 'ObjectMethod':
@@ -380,14 +381,34 @@ const hasNonEmptyResolverCall = (node, resolverName) => {
       node.arguments.some(nde => {
         return hasNonEmptyResolverCall(nde, resolverName);
       });
-    case 'ClassExpression':
-    case 'ClassDeclaration':
-      return hasNonEmptyResolverCall(node.body, resolverName);
-    case 'AwaitExpression':
-    case 'SpreadElement':
-    case 'UnaryExpression':
-    case 'YieldExpression':
-      return hasNonEmptyResolverCall(node.argument, resolverName);
+    case 'ReturnStatement':
+      {
+        if (node.argument === null) {
+          return false;
+        }
+        return hasNonEmptyResolverCall(node.argument, resolverName);
+      }
+
+    // Comma
+    case 'SequenceExpression':
+    case 'TemplateLiteral':
+      return node.expressions.some(subExpression => {
+        return hasNonEmptyResolverCall(subExpression, resolverName);
+      });
+    case 'SwitchStatement':
+      {
+        return node.cases.some(someCase => {
+          return someCase.consequent.some(nde => {
+            return hasNonEmptyResolverCall(nde, resolverName);
+          });
+        });
+      }
+    case 'TaggedTemplateExpression':
+      return hasNonEmptyResolverCall(node.quasi, resolverName);
+    case 'TryStatement':
+      {
+        return hasNonEmptyResolverCall(node.block, resolverName) || hasNonEmptyResolverCall(node.handler && node.handler.body, resolverName) || hasNonEmptyResolverCall(node.finalizer, resolverName);
+      }
     case 'VariableDeclaration':
       {
         return node.declarations.some(nde => {
@@ -398,32 +419,10 @@ const hasNonEmptyResolverCall = (node, resolverName) => {
       {
         return hasNonEmptyResolverCall(node.id, resolverName) || hasNonEmptyResolverCall(node.init, resolverName);
       }
-    case 'TaggedTemplateExpression':
-      return hasNonEmptyResolverCall(node.quasi, resolverName);
-
-    // ?.
-    /* c8 ignore next 2 -- In Babel? */
-    // @ts-expect-error Babel?
-    case 'OptionalMemberExpression':
-    case 'MemberExpression':
-      return hasNonEmptyResolverCall(node.object, resolverName) || hasNonEmptyResolverCall(node.property, resolverName);
-
-    /* c8 ignore next 2 -- In Babel? */
-    // @ts-expect-error Babel?
-    case 'Import':
-    case 'ImportExpression':
-      return hasNonEmptyResolverCall(node.source, resolverName);
-    case 'ReturnStatement':
-      {
-        if (node.argument === null) {
-          return false;
-        }
-        return hasNonEmptyResolverCall(node.argument, resolverName);
-      }
 
     /*
     // Shouldn't need to parse literals/literal components, etc.
-     case 'Identifier':
+    case 'Identifier':
     case 'TemplateElement':
     case 'Super':
     // Exports not relevant in this context
@@ -454,10 +453,11 @@ const hasValueOrExecutorHasNonEmptyResolveValue = (node, anyPromiseAsReturn, all
       hasReturn = hasReturnValue(nde, true, promiseFilter);
     } catch (error) {
       // c8 ignore else
-      if ( /** @type {Error} */error.message === 'Null return') {
+      if (/** @type {Error} */error.message === 'Null return') {
         return false;
       }
-      /* c8 ignore next 2 */
+      /* c8 ignore next 3 */
+      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
       throw error;
     }
 
@@ -481,14 +481,14 @@ const hasValueOrExecutorHasNonEmptyResolveValue = (node, anyPromiseAsReturn, all
       return false;
     }
     const {
-      params,
-      body
+      body,
+      params
     } =
     /**
      * @type {import('@typescript-eslint/types').TSESTree.FunctionExpression|
      * import('@typescript-eslint/types').TSESTree.ArrowFunctionExpression}
      */
-    ( /** @type {import('@typescript-eslint/types').TSESTree.NewExpression} */prom.arguments[0]) || {};
+    (/** @type {import('@typescript-eslint/types').TSESTree.NewExpression} */prom.arguments[0]) || {};
     if (!(params !== null && params !== void 0 && params.length)) {
       return false;
     }