eslint-plugin-jsdoc 50.6.16 → 50.7.0

package/dist/jsdocUtils.cjs

@@ -20,9 +20,9 @@ Object.defineProperty(exports, "hasValueOrExecutorHasNonEmptyResolveValue", {
 exports.tagMustHaveTypePosition = exports.tagMustHaveNamePosition = exports.tagMissingRequiredTypeOrNamepath = exports.tagMightHaveTypePosition = exports.tagMightHaveNamepath = exports.tagMightHaveNamePosition = exports.tagMightHaveEitherTypeOrNamePosition = exports.setTagStructure = exports.pathDoesNotBeginWith = exports.parseClosureTemplateTag = exports.overrideTagStructure = exports.mayBeUndefinedTypeTag = exports.isValidTag = exports.isSetter = exports.isNamepathReferencingTag = exports.isNamepathOrUrlReferencingTag = exports.isNamepathDefiningTag = exports.isGetter = exports.isConstructor = exports.hasYieldValue = void 0;
 var _getDefaultTagStructureForMode = _interopRequireDefault(require("./getDefaultTagStructureForMode.cjs"));
 var _tagNames = require("./tagNames.cjs");
-var _hasReturnValue = require("./utils/hasReturnValue.cjs");
 var _WarnSettings = _interopRequireDefault(require("./WarnSettings.cjs"));
 var _jsdoccomment = require("@es-joy/jsdoccomment");
+var _hasReturnValue = require("./utils/hasReturnValue.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * @typedef {number} Integer
@@ -175,10 +175,8 @@ const getPropertiesFromPropertySignature = propSignature => {
   }
   if (propSignature.typeAnnotation && propSignature.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
     return [/** @type {import('@typescript-eslint/types').TSESTree.Identifier} */propSignature.key.name, propSignature.typeAnnotation.typeAnnotation.members.map(member => {
-      return /** @type {string} */(
-        getPropertiesFromPropertySignature( /** @type {import('@typescript-eslint/types').TSESTree.TSPropertySignature} */
-        member)
-      );
+      return /** @type {string} */getPropertiesFromPropertySignature(/** @type {import('@typescript-eslint/types').TSESTree.TSPropertySignature} */
+      member);
     })];
   }
   return /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */propSignature.key.name;
@@ -218,7 +216,7 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
       param.typeAnnotation;
       if ((typeAnnotation === null || typeAnnotation === void 0 || (_typeAnnotation$typeA = typeAnnotation.typeAnnotation) === null || _typeAnnotation$typeA === void 0 ? void 0 : _typeAnnotation$typeA.type) === 'TSTypeLiteral') {
         const propertyNames = typeAnnotation.typeAnnotation.members.map(member => {
-          return getPropertiesFromPropertySignature( /** @type {import('@typescript-eslint/types').TSESTree.TSPropertySignature} */
+          return getPropertiesFromPropertySignature(/** @type {import('@typescript-eslint/types').TSESTree.TSPropertySignature} */
           member);
         });
         const flattened = {
@@ -240,7 +238,7 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
     }
     if (param.type === 'ObjectPattern' || 'left' in param && param.left.type === 'ObjectPattern') {
       var _param$left;
-      const properties = /** @type {import('@typescript-eslint/types').TSESTree.ObjectPattern} */param.properties || ( /** @type {import('estree').ObjectPattern} */(_param$left = /** @type {import('@typescript-eslint/types').TSESTree.AssignmentPattern} */param.left) === null || _param$left === void 0 ? void 0 : _param$left.properties);
+      const properties = /** @type {import('@typescript-eslint/types').TSESTree.ObjectPattern} */param.properties || (/** @type {import('estree').ObjectPattern} */(_param$left = /** @type {import('@typescript-eslint/types').TSESTree.AssignmentPattern} */param.left) === null || _param$left === void 0 ? void 0 : _param$left.properties);
       const roots = properties.map(prop => {
         return getParamName(prop, true);
       });
@@ -267,11 +265,19 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
         case 'AssignmentPattern':
           {
             switch (param.value.left.type) {
+              case 'ArrayPattern':
+                return [/** @type {import('estree').Identifier} */
+                param.key.name, /** @type {import('estree').ArrayPattern} */param.value.left.elements.map((prop, idx) => {
+                  return {
+                    name: idx,
+                    restElement: (prop === null || prop === void 0 ? void 0 : prop.type) === 'RestElement'
+                  };
+                })];
               case 'Identifier':
                 // Default parameter
                 if (checkDefaultObjects && param.value.right.type === 'ObjectExpression') {
                   return [/** @type {import('estree').Identifier} */param.key.name, /** @type {import('estree').AssignmentPattern} */param.value.right.properties.map(prop => {
-                    return /** @type {string} */getParamName( /** @type {import('estree').Property} */
+                    return /** @type {string} */getParamName(/** @type {import('estree').Property} */
                     prop, isProperty);
                   })];
                 }
@@ -281,14 +287,6 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
                 param.key.name, /** @type {import('estree').ObjectPattern} */param.value.left.properties.map(prop => {
                   return getParamName(prop, isProperty);
                 })];
-              case 'ArrayPattern':
-                return [/** @type {import('estree').Identifier} */
-                param.key.name, /** @type {import('estree').ArrayPattern} */param.value.left.elements.map((prop, idx) => {
-                  return {
-                    name: idx,
-                    restElement: (prop === null || prop === void 0 ? void 0 : prop.type) === 'RestElement'
-                  };
-                })];
             }
           }
       }
@@ -312,7 +310,7 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
     }
     if (param.type === 'ArrayPattern' || /** @type {import('estree').AssignmentPattern} */((_param$left2 = param.left) === null || _param$left2 === void 0 ? void 0 : _param$left2.type) === 'ArrayPattern') {
       var _param$left3;
-      const elements = /** @type {import('estree').ArrayPattern} */param.elements || ( /** @type {import('estree').ArrayPattern} */(_param$left3 = /** @type {import('estree').AssignmentPattern} */param.left) === null || _param$left3 === void 0 ? void 0 : _param$left3.elements);
+      const elements = /** @type {import('estree').ArrayPattern} */param.elements || (/** @type {import('estree').ArrayPattern} */(_param$left3 = /** @type {import('estree').AssignmentPattern} */param.left) === null || _param$left3 === void 0 ? void 0 : _param$left3.elements);
       const roots = elements.map((prop, idx) => {
         return {
           name: `"${idx}"`,
@@ -321,13 +319,14 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
       });
       return [undefined, flattenRoots(roots)];
     }
-    if (['RestElement', 'ExperimentalRestProperty'].includes(param.type)) {
+    if (['ExperimentalRestProperty', 'RestElement'].includes(param.type)) {
       var _param$argument;
       return {
         isRestProperty: isProperty,
-        name: /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */( /** @type {import('@typescript-eslint/types').TSESTree.RestElement} */param
+        name: /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */(/** @type {import('@typescript-eslint/types').TSESTree.RestElement} */param
         // @ts-expect-error Ok
         .argument).name ?? (param === null || param === void 0 || (_param$argument = param.argument) === null || _param$argument === void 0 || (_param$argument = _param$argument.elements) === null || _param$argument === void 0 ? void 0 : _param$argument.map(({
+          // @ts-expect-error Ok
           name
         }) => {
           return name;
@@ -336,7 +335,7 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
       };
     }
     if (param.type === 'TSParameterProperty') {
-      return getParamName( /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */
+      return getParamName(/** @type {import('@typescript-eslint/types').TSESTree.Identifier} */
       /** @type {import('@typescript-eslint/types').TSESTree.TSParameterProperty} */param.parameter, true);
     }
     throw new Error(`Unsupported function signature format: \`${param.type}\`.`);
@@ -344,7 +343,7 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
   if (!functionNode) {
     return [];
   }
-  return ( /** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */functionNode.params || ( /** @type {import('@typescript-eslint/types').TSESTree.MethodDefinition} */(_functionNode$value = functionNode.value) === null || _functionNode$value === void 0 ? void 0 : _functionNode$value.params) || []).map(param => {
+  return (/** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */functionNode.params || (/** @type {import('@typescript-eslint/types').TSESTree.MethodDefinition} */(_functionNode$value = functionNode.value) === null || _functionNode$value === void 0 ? void 0 : _functionNode$value.params) || []).map(param => {
     return getParamName(param);
   });
 };
@@ -399,13 +398,13 @@ const modeWarnSettings = (0, _WarnSettings.default)();
  */
 const getTagNamesForMode = (mode, context) => {
   switch (mode) {
+    case 'closure':
+    case 'permissive':
+      return _tagNames.closureTags;
     case 'jsdoc':
       return _tagNames.jsdocTags;
     case 'typescript':
       return _tagNames.typeScriptTags;
-    case 'closure':
-    case 'permissive':
-      return _tagNames.closureTags;
     default:
       if (!modeWarnSettings.hasBeenWarned(context, 'mode')) {
         context.report({
@@ -441,14 +440,14 @@ const getTagDescription = (tg, returnArray) => {
   const descriptions = [];
   tg.source.some(({
     tokens: {
+      description,
       end,
       lineEnd,
+      name,
       postDelimiter,
-      tag,
       postTag,
-      name,
-      type,
-      description
+      tag,
+      type
     }
   }) => {
     const desc = (tag && postTag || !tag && !name && !type && postDelimiter || ''
@@ -484,7 +483,9 @@ const getTagDescription = (tg, returnArray) => {
  * }}
  */
 exports.getTagDescription = getTagDescription;
-const getPreferredTagNameSimple = (name, mode, tagPreference = {}, context = {
+const getPreferredTagNameSimple = (name, mode, tagPreference = {},
+// eslint-disable-next-line unicorn/no-object-as-default-parameter -- Ok
+context = {
   report() {
     // No-op
   }
@@ -593,14 +594,14 @@ const getTags = (jsdoc, tagName) => {
  */
 exports.getTags = getTags;
 const getPreferredTagName = (jsdoc, {
-  tagName,
+  allowObjectReturn = false,
   context,
+  tagName,
+  defaultMessage = `Unexpected tag \`@${tagName}\``,
   mode,
-  tagNamePreference,
   report = () => {},
   skipReportingBlockedTag = false,
-  allowObjectReturn = false,
-  defaultMessage = `Unexpected tag \`@${tagName}\``
+  tagNamePreference
 }) => {
   const ret = getPreferredTagNameSimple(tagName, mode, tagNamePreference, context);
   const isObject = ret && typeof ret === 'object';
@@ -638,16 +639,16 @@ const forEachPreferredTag = (jsdoc, tagName, arrayHandler, {
   context,
   mode,
   report,
-  tagNamePreference,
-  skipReportingBlockedTag = false
+  skipReportingBlockedTag = false,
+  tagNamePreference
 } = {}) => {
   const targetTagName = /** @type {string|false} */
   getPreferredTagName(jsdoc, {
-    skipReportingBlockedTag,
-    tagName,
     context,
     mode,
     report,
+    skipReportingBlockedTag,
+    tagName,
     tagNamePreference
   });
   if (!targetTagName || skipReportingBlockedTag && targetTagName && typeof targetTagName === 'object') {
@@ -802,8 +803,8 @@ const ensureMap = (map, tag) => {
 const overrideTagStructure = (structuredTags, tagMap = tagStructure) => {
   for (const [tag, {
     name,
-    type,
-    required = []
+    required = [],
+    type
   }] of Object.entries(structuredTags)) {
     const tagStruct = ensureMap(tagMap, tag);
     tagStruct.set('namepathRole', name);
@@ -927,7 +928,7 @@ exports.tagMightHaveNamePosition = tagMightHaveNamePosition;
 const tagMightHaveNamepath = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   const nampathRole = tagStruct.get('namepathRole');
-  return nampathRole !== false && namepathTypes.has( /** @type {string} */nampathRole);
+  return nampathRole !== false && namepathTypes.has(/** @type {string} */nampathRole);
 };
 
 /**
@@ -990,6 +991,19 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
     return false;
   }
   switch (node.type) {
+    case 'ArrayExpression':
+    case 'ArrayPattern':
+      return node.elements.some(element => {
+        return hasNonFunctionYield(element, checkYieldReturnValue);
+      });
+    case 'AssignmentExpression':
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      {
+        return hasNonFunctionYield(node.left, checkYieldReturnValue) || hasNonFunctionYield(node.right, checkYieldReturnValue);
+      }
+    case 'AssignmentPattern':
+      return hasNonFunctionYield(node.right, checkYieldReturnValue);
     case 'BlockStatement':
       {
         return node.body.some(bodyNode => {
@@ -998,9 +1012,9 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
       }
 
     /* c8 ignore next 2 -- In Babel? */
+    case 'CallExpression':
     // @ts-expect-error In Babel?
     case 'OptionalCallExpression':
-    case 'CallExpression':
       return node.arguments.some(element => {
         return hasNonFunctionYield(element, checkYieldReturnValue);
       });
@@ -1009,82 +1023,53 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
       {
         return hasNonFunctionYield(node.expression, checkYieldReturnValue);
       }
-    case 'LabeledStatement':
-    case 'WhileStatement':
-    case 'DoWhileStatement':
-    case 'ForStatement':
-    case 'ForInStatement':
-    case 'ForOfStatement':
-    case 'WithStatement':
-      {
-        return hasNonFunctionYield(node.body, checkYieldReturnValue);
-      }
+
+    /* c8 ignore next 2 -- In Babel? */
+    // @ts-expect-error In Babel?
+    case 'ClassProperty':
+
+    /* c8 ignore next 2 -- In Babel? */
+    // @ts-expect-error In Babel?
+    case 'ObjectProperty':
+    /* c8 ignore next 2 -- In Babel? */
+    case 'Property':
+    case 'PropertyDefinition':
+      return node.computed && hasNonFunctionYield(node.key, checkYieldReturnValue) || hasNonFunctionYield(node.value, checkYieldReturnValue);
     case 'ConditionalExpression':
     case 'IfStatement':
       {
         return hasNonFunctionYield(node.test, checkYieldReturnValue) || hasNonFunctionYield(node.consequent, checkYieldReturnValue) || hasNonFunctionYield(node.alternate, checkYieldReturnValue);
       }
-    case 'TryStatement':
-      {
-        return hasNonFunctionYield(node.block, checkYieldReturnValue) || hasNonFunctionYield(node.handler && node.handler.body, checkYieldReturnValue) || hasNonFunctionYield( /** @type {import('@typescript-eslint/types').TSESTree.BlockStatement} */
-        node.finalizer, checkYieldReturnValue);
-      }
-    case 'SwitchStatement':
-      {
-        return node.cases.some(someCase => {
-          return someCase.consequent.some(nde => {
-            return hasNonFunctionYield(nde, checkYieldReturnValue);
-          });
-        });
-      }
-    case 'ArrayPattern':
-    case 'ArrayExpression':
-      return node.elements.some(element => {
-        return hasNonFunctionYield(element, checkYieldReturnValue);
-      });
-    case 'AssignmentPattern':
-      return hasNonFunctionYield(node.right, checkYieldReturnValue);
-    case 'VariableDeclaration':
-      {
-        return node.declarations.some(nde => {
-          return hasNonFunctionYield(nde, checkYieldReturnValue);
-        });
-      }
-    case 'VariableDeclarator':
-      {
-        return hasNonFunctionYield(node.id, checkYieldReturnValue) || hasNonFunctionYield(node.init, checkYieldReturnValue);
-      }
-    case 'AssignmentExpression':
-    case 'BinaryExpression':
-    case 'LogicalExpression':
+    case 'DoWhileStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'ForStatement':
+    case 'LabeledStatement':
+    case 'WhileStatement':
+    case 'WithStatement':
       {
-        return hasNonFunctionYield(node.left, checkYieldReturnValue) || hasNonFunctionYield(node.right, checkYieldReturnValue);
+        return hasNonFunctionYield(node.body, checkYieldReturnValue);
       }
 
-    // Comma
-    case 'SequenceExpression':
-    case 'TemplateLiteral':
-      return node.expressions.some(subExpression => {
-        return hasNonFunctionYield(subExpression, checkYieldReturnValue);
-      });
-    case 'ObjectPattern':
-    case 'ObjectExpression':
-      return node.properties.some(property => {
-        return hasNonFunctionYield(property, checkYieldReturnValue);
-      });
-
-    /* c8 ignore next -- In Babel? */
-    case 'PropertyDefinition':
-    /* eslint-disable no-fallthrough */
     /* c8 ignore next 2 -- In Babel? */
     // @ts-expect-error In Babel?
-    case 'ObjectProperty':
+    case 'Import':
+    case 'ImportExpression':
+      return hasNonFunctionYield(node.source, checkYieldReturnValue);
+
+    // ?.
     /* c8 ignore next 2 -- In Babel? */
+    case 'MemberExpression':
     // @ts-expect-error In Babel?
-    case 'ClassProperty':
-    case 'Property':
+    case 'OptionalMemberExpression':
+      return hasNonFunctionYield(node.object, checkYieldReturnValue) || hasNonFunctionYield(node.property, checkYieldReturnValue);
+    case 'ObjectExpression':
+    /* eslint-disable no-fallthrough */
+    case 'ObjectPattern':
       /* eslint-enable no-fallthrough */
-      return node.computed && hasNonFunctionYield(node.key, checkYieldReturnValue) || hasNonFunctionYield(node.value, checkYieldReturnValue);
+      return node.properties.some(property => {
+        return hasNonFunctionYield(property, checkYieldReturnValue);
+      });
     /* c8 ignore next 2 -- In Babel? */
     // @ts-expect-error In Babel?
     case 'ObjectMethod':
@@ -1095,24 +1080,6 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
       node.arguments.some(nde => {
         return hasNonFunctionYield(nde, checkYieldReturnValue);
       });
-    case 'SpreadElement':
-    case 'UnaryExpression':
-      return hasNonFunctionYield(node.argument, checkYieldReturnValue);
-    case 'TaggedTemplateExpression':
-      return hasNonFunctionYield(node.quasi, checkYieldReturnValue);
-
-    // ?.
-    /* c8 ignore next 2 -- In Babel? */
-    // @ts-expect-error In Babel?
-    case 'OptionalMemberExpression':
-    case 'MemberExpression':
-      return hasNonFunctionYield(node.object, checkYieldReturnValue) || hasNonFunctionYield(node.property, checkYieldReturnValue);
-
-    /* c8 ignore next 2 -- In Babel? */
-    // @ts-expect-error In Babel?
-    case 'Import':
-    case 'ImportExpression':
-      return hasNonFunctionYield(node.source, checkYieldReturnValue);
     case 'ReturnStatement':
       {
         if (node.argument === null) {
@@ -1120,10 +1087,45 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
         }
         return hasNonFunctionYield(node.argument, checkYieldReturnValue);
       }
+
+    // Comma
+    case 'SequenceExpression':
+    case 'TemplateLiteral':
+      return node.expressions.some(subExpression => {
+        return hasNonFunctionYield(subExpression, checkYieldReturnValue);
+      });
+    case 'SpreadElement':
+    case 'UnaryExpression':
+      return hasNonFunctionYield(node.argument, checkYieldReturnValue);
+    case 'SwitchStatement':
+      {
+        return node.cases.some(someCase => {
+          return someCase.consequent.some(nde => {
+            return hasNonFunctionYield(nde, checkYieldReturnValue);
+          });
+        });
+      }
+    case 'TaggedTemplateExpression':
+      return hasNonFunctionYield(node.quasi, checkYieldReturnValue);
+    case 'TryStatement':
+      {
+        return hasNonFunctionYield(node.block, checkYieldReturnValue) || hasNonFunctionYield(node.handler && node.handler.body, checkYieldReturnValue) || hasNonFunctionYield(/** @type {import('@typescript-eslint/types').TSESTree.BlockStatement} */
+        node.finalizer, checkYieldReturnValue);
+      }
+    case 'VariableDeclaration':
+      {
+        return node.declarations.some(nde => {
+          return hasNonFunctionYield(nde, checkYieldReturnValue);
+        });
+      }
+    case 'VariableDeclarator':
+      {
+        return hasNonFunctionYield(node.id, checkYieldReturnValue) || hasNonFunctionYield(node.init, checkYieldReturnValue);
+      }
     case 'YieldExpression':
       {
         if (checkYieldReturnValue) {
-          if ( /** @type {import('eslint').Rule.Node} */node.parent.type === 'VariableDeclarator') {
+          if (/** @type {import('eslint').Rule.Node} */node.parent.type === 'VariableDeclarator') {
             return true;
           }
           return false;
@@ -1149,7 +1151,7 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
  * @returns {boolean}
  */
 const hasYieldValue = (node, checkYieldReturnValue) => {
-  return /** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */node.generator && ( /** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */node.expression || hasNonFunctionYield( /** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */
+  return /** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */node.generator && (/** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */node.expression || hasNonFunctionYield(/** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */
   node.body, checkYieldReturnValue));
 };
 
@@ -1170,9 +1172,9 @@ const hasThrowValue = (node, innerFunction) => {
   //   throws, but we're treating functions atomically rather than trying to
   //   follow them
   switch (node.type) {
-    case 'FunctionExpression':
-    case 'FunctionDeclaration':
     case 'ArrowFunctionExpression':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
       {
         return !innerFunction && !node.async && hasThrowValue(node.body, true);
       }
@@ -1182,12 +1184,12 @@ const hasThrowValue = (node, innerFunction) => {
           return bodyNode.type !== 'FunctionDeclaration' && hasThrowValue(bodyNode);
         });
       }
-    case 'LabeledStatement':
-    case 'WhileStatement':
     case 'DoWhileStatement':
-    case 'ForStatement':
     case 'ForInStatement':
     case 'ForOfStatement':
+    case 'ForStatement':
+    case 'LabeledStatement':
+    case 'WhileStatement':
     case 'WithStatement':
       {
         return hasThrowValue(node.body);
@@ -1196,12 +1198,6 @@ const hasThrowValue = (node, innerFunction) => {
       {
         return hasThrowValue(node.consequent) || hasThrowValue(node.alternate);
       }
-
-    // We only consider it to throw an error if the catch or finally blocks throw an error.
-    case 'TryStatement':
-      {
-        return hasThrowValue(node.handler && node.handler.body) || hasThrowValue(node.finalizer);
-      }
     case 'SwitchStatement':
       {
         return node.cases.some(someCase => {
@@ -1214,6 +1210,12 @@ const hasThrowValue = (node, innerFunction) => {
       {
         return true;
       }
+
+    // We only consider it to throw an error if the catch or finally blocks throw an error.
+    case 'TryStatement':
+      {
+        return hasThrowValue(node.handler && node.handler.body) || hasThrowValue(node.finalizer);
+      }
     default:
       {
         return false;
@@ -1327,9 +1329,9 @@ const getContextObject = (contexts, checkJsdoc, handler) => {
   return properties;
 };
 exports.getContextObject = getContextObject;
-const tagsWithNamesAndDescriptions = new Set(['param', 'arg', 'argument', 'property', 'prop', 'template',
+const tagsWithNamesAndDescriptions = new Set(['arg', 'argument', 'param', 'prop', 'property', 'return',
 // These two are parsed by our custom parser as though having a `name`
-'returns', 'return']);
+'returns', 'template']);
 
 /**
  * @typedef {{
@@ -1427,9 +1429,9 @@ const isSetter = node => {
 exports.isSetter = isSetter;
 const hasAccessorPair = node => {
   const {
-    type,
+    key,
     kind: sourceKind,
-    key
+    type
   } =
   /**
    * @type {import('@typescript-eslint/types').TSESTree.MethodDefinition|
@@ -1441,8 +1443,8 @@ const hasAccessorPair = node => {
   const sibling = type === 'MethodDefinition' ? /** @type {import('@typescript-eslint/types').TSESTree.ClassBody} */node.parent.body : /** @type {import('@typescript-eslint/types').TSESTree.ObjectExpression} */node.parent.properties;
   return sibling.some(child => {
     const {
-      kind,
-      key: ky
+      key: ky,
+      kind
     } =
     /**
      * @type {import('@typescript-eslint/types').TSESTree.MethodDefinition|
@@ -1473,7 +1475,7 @@ const exemptSpeciaMethods = (jsdoc, node, context, schema) => {
   };
   const checkGetters = hasSchemaOption('checkGetters');
   const checkSetters = hasSchemaOption('checkSetters');
-  return !hasSchemaOption('checkConstructors') && (isConstructor(node) || hasATag(jsdoc, ['class', 'constructor'])) || isGetter(node) && (!checkGetters || checkGetters === 'no-setter' && hasAccessorPair( /** @type {import('./iterateJsdoc.js').Node} */node.parent)) || isSetter(node) && (!checkSetters || checkSetters === 'no-getter' && hasAccessorPair( /** @type {import('./iterateJsdoc.js').Node} */node.parent));
+  return !hasSchemaOption('checkConstructors') && (isConstructor(node) || hasATag(jsdoc, ['class', 'constructor'])) || isGetter(node) && (!checkGetters || checkGetters === 'no-setter' && hasAccessorPair(/** @type {import('./iterateJsdoc.js').Node} */node.parent)) || isSetter(node) && (!checkSetters || checkSetters === 'no-getter' && hasAccessorPair(/** @type {import('./iterateJsdoc.js').Node} */node.parent));
 };
 
 /**