eslint-plugin-jsdoc 44.2.3 → 44.2.4

package/dist/jsdocUtils.js

@@ -42,14 +42,43 @@ const setTagStructure = mode => {
  * }} FlattendRootInfo
  */
 
+/**
+ * @typedef {undefined|string|{
+ *   isRestProperty: boolean|undefined,
+ *   name: string,
+ *   restElement: true
+ * }|[undefined|string, FlattendRootInfo & {
+ *   annotationParamName?: string
+ * }|{
+ *   name: Integer,
+ *   restElement: boolean
+ * }[]]} ParamNameInfo
+ */
+
+/**
+ * @typedef {undefined|string|{
+ *   isRestProperty: boolean,
+ *   restElement: boolean,
+ *   name: string
+ * }|[string, {
+ *   hasPropertyRest: boolean,
+ *   hasRestElement: boolean,
+ *   names: string[],
+ *   rests: boolean[],
+ * }]|[string, string[]]} ParamInfo
+ */
+
 /**
  * Given a nested array of property names, reduce them to a single array,
  *   appending the name of the root element along the way if present.
  *
- * @param {} params
- * @param {string} root
+ * @callback FlattenRoots
+ * @param {ParamInfo[]} params
+ * @param {string} [root]
  * @returns {FlattendRootInfo}
  */
+
+/** @type {FlattenRoots} */
 const flattenRoots = (params, root = '') => {
   let hasRestElement = false;
   let hasPropertyRest = false;
@@ -58,7 +87,13 @@ const flattenRoots = (params, root = '') => {
    * @type {boolean[]}
    */
   const rests = [];
-  const names = params.reduce((acc, cur) => {
+  const names = params.reduce(
+  /**
+   * @param {string[]} acc
+   * @param {ParamInfo} cur
+   * @returns {string[]}
+   */
+  (acc, cur) => {
     if (Array.isArray(cur)) {
       let nms;
       if (Array.isArray(cur[1])) {
@@ -109,59 +144,68 @@ const flattenRoots = (params, root = '') => {
 };
 
 /**
- * @param {ESTreeOrTypeScriptNode} propSignature
- * @returns {undefined|Array|string}
+ * @param {import('@typescript-eslint/types').TSESTree.TSIndexSignature|
+ *  import('@typescript-eslint/types').TSESTree.TSConstructSignatureDeclaration|
+ *  import('@typescript-eslint/types').TSESTree.TSCallSignatureDeclaration|
+ *  import('@typescript-eslint/types').TSESTree.TSPropertySignature} propSignature
+ * @returns {undefined|string|[string, string[]]}
  */
 const getPropertiesFromPropertySignature = propSignature => {
   if (propSignature.type === 'TSIndexSignature' || propSignature.type === 'TSConstructSignatureDeclaration' || propSignature.type === 'TSCallSignatureDeclaration') {
     return undefined;
   }
   if (propSignature.typeAnnotation && propSignature.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
-    return [propSignature.key.name, propSignature.typeAnnotation.typeAnnotation.members.map(member => {
-      return getPropertiesFromPropertySignature(member);
+    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 propSignature.key.name;
+  return (/** @type {import('@typescript-eslint/types').TSESTree.Identifier} */propSignature.key.name
+  );
 };
 
 /**
- * @param {ESTreeOrTypeScriptNode} functionNode
+ * @param {ESTreeOrTypeScriptNode|null} functionNode
  * @param {boolean} [checkDefaultObjects]
- * @returns {Array}
+ * @throws {Error}
+ * @returns {ParamNameInfo[]}
  */
 const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
   var _functionNode$value;
   /* eslint-disable complexity -- Temporary */
   /**
-   * @param {} param
+   * @param {import('estree').Identifier|import('estree').AssignmentPattern|
+   *   import('estree').ObjectPattern|import('estree').Property|
+   *   import('estree').RestElement|import('estree').ArrayPattern|
+   *   import('@typescript-eslint/types').TSESTree.TSParameterProperty|
+   *   import('@typescript-eslint/types').TSESTree.Property|
+   *   import('@typescript-eslint/types').TSESTree.RestElement
+   * } param
    * @param {boolean} [isProperty]
-   * @returns {undefined|{
-   *   isRestProperty: boolean|undefined,
-   *   name: string,
-   *   restElement: true
-   * }|[undefined|string, FlattendRootInfo|{
-   *   name: Integer,
-   *   restElement: boolean
-   * }[]]}
+   * @returns {ParamNameInfo}
    */
   const getParamName = (param, isProperty) => {
-    var _param$left, _param$left3;
+    var _param$left2;
     /* eslint-enable complexity -- Temporary */
     const hasLeftTypeAnnotation = 'left' in param && 'typeAnnotation' in param.left;
     if ('typeAnnotation' in param || hasLeftTypeAnnotation) {
       var _typeAnnotation$typeA;
-      const typeAnnotation = hasLeftTypeAnnotation ? param.left.typeAnnotation : param.typeAnnotation;
+      const typeAnnotation = hasLeftTypeAnnotation ? /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */param.left.typeAnnotation : /** @type {import('@typescript-eslint/types').TSESTree.Identifier|import('@typescript-eslint/types').TSESTree.ObjectPattern} */
+      param.typeAnnotation;
       if ((typeAnnotation === null || typeAnnotation === void 0 ? 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(member);
+          return getPropertiesFromPropertySignature( /** @type {import('@typescript-eslint/types').TSESTree.TSPropertySignature} */
+          member);
         });
         const flattened = {
           ...flattenRoots(propertyNames),
-          annotationParamName: param.name
+          annotationParamName: 'name' in param ? param.name : undefined
         };
         const hasLeftName = 'left' in param && 'name' in param.left;
         if ('name' in param || hasLeftName) {
-          return [hasLeftName ? param.left.name : param.name, flattened];
+          return [hasLeftName ? /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */param.left.name : /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */param.name, flattened];
         }
         return [undefined, flattened];
       }
@@ -172,9 +216,9 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
     if ('left' in param && 'name' in param.left) {
       return param.left.name;
     }
-    if (param.type === 'ObjectPattern' || ((_param$left = param.left) === null || _param$left === void 0 ? void 0 : _param$left.type) === 'ObjectPattern') {
-      var _param$left2;
-      const properties = param.properties || ((_param$left2 = param.left) === null || _param$left2 === void 0 ? void 0 : _param$left2.properties);
+    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 roots = properties.map(prop => {
         return getParamName(prop, true);
       });
@@ -239,9 +283,9 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
           return undefined;
       }
     }
-    if (param.type === 'ArrayPattern' || ((_param$left3 = param.left) === null || _param$left3 === void 0 ? void 0 : _param$left3.type) === 'ArrayPattern') {
-      var _param$left4;
-      const elements = /** @type {import('estree').ArrayPattern} */param.elements || ( /** @type {import('estree').ArrayPattern} */(_param$left4 = param.left) === null || _param$left4 === void 0 ? void 0 : _param$left4.elements);
+    if (param.type === 'ArrayPattern' || ((_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 = param.left) === null || _param$left3 === void 0 ? void 0 : _param$left3.elements);
       const roots = elements.map((prop, idx) => {
         return {
           name: `"${idx}"`,
@@ -312,7 +356,7 @@ const getJsdocTagsDeep = (jsdoc, targetTagName) => {
 const modeWarnSettings = (0, _WarnSettings.default)();
 
 /**
- * @param {ParserMode} mode
+ * @param {ParserMode|undefined} mode
  * @param {import('eslint').Rule.RuleContext} context
  * @returns {import('./tagNames.js').AliasedTags}
  */
@@ -346,10 +390,10 @@ const getTagNamesForMode = (mode, context) => {
 
 /**
  * @param {import('eslint').Rule.RuleContext} context
- * @param {ParserMode} mode
+ * @param {ParserMode|undefined} mode
  * @param {string} name
  * @param {TagNamePreference} tagPreference
- * @returns {string|boolean|{
+ * @returns {string|false|{
  *   message: string;
  *   replacement?: string|undefined;
  * }}
@@ -385,10 +429,10 @@ const getPreferredTagName = (context, mode, name, tagPreference = {}) => {
 };
 
 /**
- * @param context
- * @param {ParserMode} mode
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {ParserMode|undefined} mode
  * @param {string} name
- * @param {Array} definedTags
+ * @param {string[]} definedTags
  * @returns {boolean}
  */
 const isValidTag = (context, mode, name, definedTags) => {
@@ -400,7 +444,9 @@ const isValidTag = (context, mode, name, definedTags) => {
 };
 
 /**
- * @param {object} jsdoc
+ * @param {import('comment-parser').Block & {
+ *   inlineTags: import('@es-joy/jsdoccomment').InlineTag[]
+ * }} jsdoc
  * @param {string} targetTagName
  * @returns {boolean}
  */
@@ -417,12 +463,11 @@ const hasTag = (jsdoc, targetTagName) => {
  * @param {import('comment-parser').Block & {
  *   inlineTags: import('@es-joy/jsdoccomment').JsdocInlineTagNoType[]
  * }} jsdoc
- * @param {boolean} includeInlineTags
  * @returns {(import('comment-parser').Spec|
  *   import('@es-joy/jsdoccomment').JsdocInlineTagNoType)[]}
  */
-const getAllTags = (jsdoc, includeInlineTags) => {
-  return includeInlineTags ? [...jsdoc.tags, ...jsdoc.inlineTags.map(inlineTag => {
+const getAllTags = jsdoc => {
+  return [...jsdoc.tags, ...jsdoc.inlineTags.map(inlineTag => {
     // Tags don't have source or line numbers, so add before returning
     let line = -1;
     for (const {
@@ -472,11 +517,11 @@ const getAllTags = (jsdoc, includeInlineTags) => {
        */
       tag.inlineTags
     );
-  })] : jsdoc.tags;
+  })];
 };
 
 /**
- * @param {object} jsdoc
+ * @param {import('comment-parser').Block} jsdoc
  * @param {string[]} targetTagNames
  * @returns {boolean}
  */
@@ -489,7 +534,7 @@ const hasATag = (jsdoc, targetTagNames) => {
 /**
  * Checks if the JSDoc comment has an undefined type.
  *
- * @param {import('comment-parser').Spec} tag
+ * @param {import('comment-parser').Spec|null|undefined} tag
  *   the tag which should be checked.
  * @param {ParserMode} mode
  * @returns {boolean}
@@ -529,7 +574,7 @@ const mayBeUndefinedTypeTag = (tag, mode) => {
 /**
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} map
  * @param {string} tag
- * @returns {Map<string, string | boolean>}
+ * @returns {Map<string, string|string[]|boolean|undefined>}
  */
 const ensureMap = (map, tag) => {
   if (!map.has(tag)) {
@@ -539,20 +584,8 @@ const ensureMap = (map, tag) => {
   );
 };
 
-/* eslint-disable jsdoc/valid-types -- Older non-TS version */
 /**
- * @typedef {{
- *   [tag: string]: {
- *     name: string|boolean,
- *     type: string[]|boolean,
- *     required: string[]
- *   }
- * }} StructuredTags
- */
-/* eslint-enable jsdoc/valid-types -- Older non-TS version */
-
-/**
- * @param {StructuredTags} structuredTags
+ * @param {import('./iterateJsdoc.js').StructuredTags} structuredTags
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
  * @returns {void}
  */
@@ -588,7 +621,7 @@ const overrideTagStructure = (structuredTags, tagMap = tagStructure) => {
 
 /**
  * @param {ParserMode} mode
- * @param {StructuredTags} structuredTags
+ * @param {import('./iterateJsdoc.js').StructuredTags} structuredTags
  * @returns {import('./getDefaultTagStructureForMode.js').TagStructure}
  */
 const getTagStructureForMode = (mode, structuredTags) => {
@@ -634,11 +667,12 @@ const isNamepathOrUrlReferencingTag = (tag, tagMap = tagStructure) => {
 /**
  * @param {string} tag
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
- * @returns {boolean}
+ * @returns {boolean|undefined}
  */
 const tagMustHaveTypePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
-  return tagStruct.get('typeRequired');
+  return (/** @type {boolean|undefined} */tagStruct.get('typeRequired')
+  );
 };
 
 /**
@@ -680,36 +714,38 @@ const tagMightHaveNamepath = (tag, tagMap = tagStructure) => {
 /**
  * @param {string} tag
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
- * @returns {boolean}
+ * @returns {boolean|undefined}
  */
 const tagMustHaveNamePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
-  return tagStruct.get('nameRequired');
+  return (/** @type {boolean|undefined} */tagStruct.get('nameRequired')
+  );
 };
 
 /**
- * @param tag
+ * @param {string} tag
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
  * @returns {boolean}
  */
 const tagMightHaveEitherTypeOrNamePosition = (tag, tagMap) => {
-  return tagMightHaveTypePosition(tag, tagMap) || tagMightHaveNamepath(tag, tagMap);
+  return Boolean(tagMightHaveTypePosition(tag, tagMap)) || tagMightHaveNamepath(tag, tagMap);
 };
 
 /**
  * @param {string} tag
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
- * @returns {boolean}
+ * @returns {boolean|undefined}
  */
 const tagMustHaveEitherTypeOrNamePosition = (tag, tagMap) => {
   const tagStruct = ensureMap(tagMap, tag);
-  return tagStruct.get('typeOrNameRequired');
+  return (/** @type {boolean} */tagStruct.get('typeOrNameRequired')
+  );
 };
 
 /**
- * @param tag
+ * @param {import('comment-parser').Spec} tag
  * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
- * @returns {boolean}
+ * @returns {boolean|undefined}
  */
 const tagMissingRequiredTypeOrNamepath = (tag, tagMap = tagStructure) => {
   const mustHaveTypePosition = tagMustHaveTypePosition(tag.tag, tagMap);
@@ -740,6 +776,7 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
         });
       }
 
+    // @ts-expect-error In Babel?
     // istanbul ignore next -- In Babel?
     case 'OptionalCallExpression':
     case 'CallExpression':
@@ -817,13 +854,16 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
     // istanbul ignore next -- In Babel?
     case 'PropertyDefinition':
     /* eslint-disable no-fallthrough */
+    // @ts-expect-error In Babel?
     // istanbul ignore next -- In Babel?
     case 'ObjectProperty':
+    // @ts-expect-error In Babel?
     // istanbul ignore next -- In Babel?
     case 'ClassProperty':
     case 'Property':
       /* eslint-enable no-fallthrough */
       return node.computed && hasNonFunctionYield(node.key, checkYieldReturnValue) || hasNonFunctionYield(node.value, checkYieldReturnValue);
+    // @ts-expect-error In Babel?
     // istanbul ignore next -- In Babel?
     case 'ObjectMethod':
       // istanbul ignore next -- In Babel?
@@ -836,12 +876,14 @@ const hasNonFunctionYield = (node, checkYieldReturnValue) => {
     case 'TaggedTemplateExpression':
       return hasNonFunctionYield(node.quasi, checkYieldReturnValue);
 
+    // @ts-expect-error In Babel?
     // ?.
     // istanbul ignore next -- In Babel?
     case 'OptionalMemberExpression':
     case 'MemberExpression':
       return hasNonFunctionYield(node.object, checkYieldReturnValue) || hasNonFunctionYield(node.property, checkYieldReturnValue);
 
+    // @ts-expect-error In Babel?
     // istanbul ignore next -- In Babel?
     case 'Import':
     case 'ImportExpression':
@@ -889,7 +931,7 @@ const hasYieldValue = (node, checkYieldReturnValue) => {
 /**
  * Checks if a node has a throws statement.
  *
- * @param {ESTreeOrTypeScriptNode} node
+ * @param {ESTreeOrTypeScriptNode|null|undefined} node
  * @param {boolean} [innerFunction]
  * @returns {boolean}
  */
@@ -987,8 +1029,10 @@ const parseClosureTemplateTag = tag => {
  *   ESTree AST types, indicating allowable contexts.
  *
  * @param {import('eslint').Rule.RuleContext} context
- * @param {DefaultContexts} defaultContexts
- * @param settings
+ * @param {DefaultContexts|undefined} defaultContexts
+ * @param {{
+ *   contexts?: import('./iterateJsdoc.js').Context[]
+ * }} settings
  * @returns {string[]}
  */
 const enforcedContexts = (context, defaultContexts, settings) => {
@@ -998,11 +1042,13 @@ const enforcedContexts = (context, defaultContexts, settings) => {
 };
 
 /**
- * @param {string[]} contexts
- * @param {Function} checkJsdoc
- * @param {Function} handler
+ * @param {import('./iterateJsdoc.js').Context[]} contexts
+ * @param {import('./iterateJsdoc.js').CheckJsdoc} checkJsdoc
+ * @param {Function} [handler]
+ * @returns {import('eslint').Rule.RuleListener}
  */
 const getContextObject = (contexts, checkJsdoc, handler) => {
+  /** @type {import('eslint').Rule.RuleListener} */
   const properties = {};
   for (const [idx, prop] of contexts.entries()) {
     let property;
@@ -1038,11 +1084,6 @@ const getContextObject = (contexts, checkJsdoc, handler) => {
   }
   return properties;
 };
-const filterTags = (tags, filter) => {
-  return tags.filter(tag => {
-    return filter(tag);
-  });
-};
 const tagsWithNamesAndDescriptions = new Set(['param', 'arg', 'argument', 'property', 'prop', 'template',
 // These two are parsed by our custom parser as though having a `name`
 'returns', 'return']);
@@ -1058,7 +1099,7 @@ const tagsWithNamesAndDescriptions = new Set(['param', 'arg', 'argument', 'prope
 
 /**
  * @param {import('eslint').Rule.RuleContext} context
- * @param {ParserMode} mode
+ * @param {ParserMode|undefined} mode
  * @param {import('comment-parser').Spec[]} tags
  * @param {TagNamePreference} tagPreference
  * @returns {{
@@ -1072,7 +1113,7 @@ const getTagsByType = (context, mode, tags, tagPreference) => {
    * @type {import('comment-parser').Spec[]}
    */
   const tagsWithoutNames = [];
-  const tagsWithNames = filterTags(tags, tag => {
+  const tagsWithNames = tags.filter(tag => {
     const {
       tag: tagName
     } = tag;
@@ -1089,7 +1130,9 @@ const getTagsByType = (context, mode, tags, tagPreference) => {
 };
 
 /**
- * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('eslint').SourceCode|{
+ *   text: string
+ * }} sourceCode
  * @returns {string}
  */
 const getIndent = sourceCode => {
@@ -1098,64 +1141,87 @@ const getIndent = sourceCode => {
 };
 
 /**
- * @param {ESTreeOrTypeScriptNode} node
+ * @param {import('eslint').Rule.Node|null} node
  * @returns {boolean}
  */
 const isConstructor = node => {
   var _node$parent;
-  return (node === null || node === void 0 ? void 0 : node.type) === 'MethodDefinition' && node.kind === 'constructor' || (node === null || node === void 0 ? void 0 : (_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.kind) === 'constructor';
+  return (node === null || node === void 0 ? void 0 : node.type) === 'MethodDefinition' && node.kind === 'constructor' || /** @type {import('@typescript-eslint/types').TSESTree.MethodDefinition} */(node === null || node === void 0 ? void 0 : (_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.kind) === 'constructor';
 };
 
 /**
- * @param {ESTreeOrTypeScriptNode} node
+ * @param {import('eslint').Rule.Node|null} node
  * @returns {boolean}
  */
 const isGetter = node => {
   var _node$parent2;
-  return node && ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.kind) === 'get';
+  return node !== null &&
+  /**
+   * @type {import('@typescript-eslint/types').TSESTree.MethodDefinition|
+   *   import('@typescript-eslint/types').TSESTree.Property}
+   */
+  ((_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.kind) === 'get';
 };
 
 /**
- * @param {ESTreeOrTypeScriptNode} node
+ * @param {import('eslint').Rule.Node|null} node
  * @returns {boolean}
  */
 const isSetter = node => {
   var _node$parent3;
-  return node && ((_node$parent3 = node.parent) === null || _node$parent3 === void 0 ? void 0 : _node$parent3.kind) === 'set';
+  return node !== null &&
+  /**
+   * @type {import('@typescript-eslint/types').TSESTree.MethodDefinition|
+   *   import('@typescript-eslint/types').TSESTree.Property}
+   */
+  ((_node$parent3 = node.parent) === null || _node$parent3 === void 0 ? void 0 : _node$parent3.kind) === 'set';
 };
 
 /**
- * @param {ESTreeOrTypeScriptNode} node
+ * @param {import('eslint').Rule.Node} node
  * @returns {boolean}
  */
 const hasAccessorPair = node => {
   const {
     type,
     kind: sourceKind,
-    key: {
-      name: sourceName
-    }
-  } = node;
+    key
+  } =
+  /**
+   * @type {import('@typescript-eslint/types').TSESTree.MethodDefinition|
+   *   import('@typescript-eslint/types').TSESTree.Property}
+   */
+  node;
+  const sourceName = /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */key.name;
   const oppositeKind = sourceKind === 'get' ? 'set' : 'get';
-  const children = type === 'MethodDefinition' ? 'body' : 'properties';
-  return node.parent[children].some(({
-    kind,
-    key: {
-      name
-    }
-  }) => {
+  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
+    } =
+    /**
+     * @type {import('@typescript-eslint/types').TSESTree.MethodDefinition|
+     *   import('@typescript-eslint/types').TSESTree.Property}
+     */
+    child;
+    const name = /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */ky.name;
     return kind === oppositeKind && name === sourceName;
   });
 };
 
 /**
  * @param {import('comment-parser').Block} jsdoc
- * @param {ESTreeOrTypeScriptNode} node
+ * @param {import('eslint').Rule.Node|null} node
  * @param {import('eslint').Rule.RuleContext} context
- * @param {} schema
+ * @param {import('json-schema').JSONSchema4} schema
  * @returns {boolean}
  */
 const exemptSpeciaMethods = (jsdoc, node, context, schema) => {
+  /**
+   * @param {"checkGetters"|"checkSetters"|"checkConstructors"} prop
+   * @returns {boolean|"no-setter"|"no-getter"}
+   */
   const hasSchemaOption = prop => {
     var _context$options$2;
     const schemaProperties = schema[0].properties;
@@ -1163,7 +1229,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(node.parent)) || isSetter(node) && (!checkSetters || checkSetters === 'no-getter' && hasAccessorPair(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));
 };
 
 /**
@@ -1190,17 +1256,20 @@ const comparePaths = name => {
 };
 
 /**
+ * @callback PathDoesNotBeginWith
  * @param {string} name
  * @param {string} otherPathName
  * @returns {boolean}
  */
+
+/** @type {PathDoesNotBeginWith} */
 const pathDoesNotBeginWith = (name, otherPathName) => {
   return !name.startsWith(otherPathName) && !dropPathSegmentQuotes(name).startsWith(dropPathSegmentQuotes(otherPathName));
 };
 
 /**
  * @param {string} regexString
- * @param {string} requiredFlags
+ * @param {string} [requiredFlags]
  * @returns {RegExp}
  */
 const getRegexFromString = (regexString, requiredFlags) => {
@@ -1222,7 +1291,6 @@ var _default = {
   dropPathSegmentQuotes,
   enforcedContexts,
   exemptSpeciaMethods,
-  filterTags,
   flattenRoots,
   getAllTags,
   getContextObject,