- Refactoring: For no-undefined-types, rename tagsWithNames check to isNamepathDefiningTag

- Refactoring: For `check-types`, move tag with type check to utils
- Refactoring: For `valid-types`, rename util (`isNamepathType -> `isNamepathTag`)

Author: brettz9

src/iterateJsdoc.js

@@ -141,8 +141,16 @@ const curryUtils = (
   utils.isAugmentsExtendsAllowedWithoutParam = () => {
     return allowAugmentsExtendsWithoutParam;
   };
-  utils.isNamepathType = (tagName) => {
-    return jsdocUtils.isNamepathType(tagName, checkSeesForNamepaths);
+
+  utils.isNamepathDefiningTag = (tagName) => {
+    return jsdocUtils.isNamepathDefiningTag(tagName);
+  };
+  utils.isNamepathTag = (tagName) => {
+    return jsdocUtils.isNamepathTag(tagName, checkSeesForNamepaths);
+  };
+
+  utils.isTagWithType = (tagName) => {
+    return jsdocUtils.isTagWithType(tagName);
   };
 
   utils.avoidExampleOnConstructors = () => {

src/jsdocUtils.js

@@ -117,29 +117,91 @@ const hasDefinedTypeReturnTag = (tag) => {
   return true;
 };
 
-const namepathAsNameTags = [
+const namepathDefiningTags = [
+  // NOT USEFUL WITHOUT NAMEPATH
+  'class', 'constructor',
+  'constant', 'const',
+  'external', 'host',
+  'function', 'func', 'method',
+  'interface',
+  'member', 'var',
+  'mixin',
+  'name',
+  'namespace',
+  'type',
+  'typedef',
+
+  // MAY BE USEFUL WITHOUT NAMEPATH
+  'callback',
+  'event'
+];
+
+const namepathPointingTags = [
+  // NOT USEFUL WITHOUT NAMEPATH
   'alias',
   'augments',
-  'callback',
+
+  // `borrows` has a different format, however, so needs special parsing
+  'borrows',
   'extends',
   'lends',
   'memberof',
   'memberof!',
   'mixes',
-  'name',
   'this',
 
+  // MAY BE USEFUL WITHOUT NAMEPATH
   'emits',
-  'event',
   'fires',
   'listens'
 ];
 
-const isNamepathType = (tagName, checkSeesForNamepaths) => {
-  return namepathAsNameTags.includes(tagName) ||
+const isNamepathDefiningTag = (tagName) => {
+  return namepathDefiningTags.includes(tagName);
+};
+
+const isNamepathPointingTag = (tagName, checkSeesForNamepaths) => {
+  return namepathPointingTags.includes(tagName) ||
     tagName === 'see' && checkSeesForNamepaths;
 };
 
+const isNamepathTag = (tagName, checkSeesForNamepaths) => {
+  return isNamepathDefiningTag(tagName) ||
+    isNamepathPointingTag(tagName, checkSeesForNamepaths);
+};
+
+let tagsWithTypes = [
+  'class',
+  'constant',
+  'enum',
+  'member',
+  'module',
+  'namespace',
+  'param',
+  'property',
+  'returns',
+  'throws',
+  'type',
+  'typedef'
+];
+
+const tagsWithTypesAliases = [
+  'constructor',
+  'const',
+  'var',
+  'arg',
+  'argument',
+  'prop',
+  'return',
+  'exception'
+];
+
+tagsWithTypes = tagsWithTypes.concat(tagsWithTypesAliases);
+
+const isTagWithType = (tagName) => {
+  return tagsWithTypes.includes(tagName);
+};
+
 const LOOP_STATEMENTS = ['WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement'];
 
 const STATEMENTS_WITH_CHILDREN = [
@@ -365,6 +427,8 @@ export default {
   hasDefinedTypeReturnTag,
   hasReturnValue,
   hasTag,
-  isNamepathType,
+  isNamepathDefiningTag,
+  isNamepathTag,
+  isTagWithType,
   isValidTag
 };

src/rules/checkTypes.js

@@ -1,34 +1,6 @@
 import {parse, traverse, publish} from 'jsdoctypeparser';
 import iterateJsdoc from '../iterateJsdoc';
 
-let targetTags = [
-  'class',
-  'constant',
-  'enum',
-  'member',
-  'module',
-  'namespace',
-  'param',
-  'property',
-  'returns',
-  'throws',
-  'type',
-  'typedef'
-];
-
-const targetTagAliases = [
-  'constructor',
-  'const',
-  'var',
-  'arg',
-  'argument',
-  'prop',
-  'return',
-  'exception'
-];
-
-targetTags = targetTags.concat(targetTagAliases);
-
 const strictNativeTypes = [
   'undefined',
   'null',
@@ -46,10 +18,11 @@ export default iterateJsdoc(({
   jsdoc,
   jsdocNode,
   sourceCode,
-  report
+  report,
+  utils
 }) => {
   const jsdocTags = jsdoc.tags.filter((tag) => {
-    return targetTags.includes(tag.tag);
+    return utils.isTagWithType(tag.tag);
   });
 
   jsdocTags.forEach((jsdocTag) => {

src/rules/noUndefinedTypes.js

@@ -6,27 +6,13 @@ const extraTypes = [
   'null', 'undefined', 'string', 'number', 'boolean', 'any', '*',
   'Array', 'Object', 'RegExp', 'Date', 'Function'
 ];
-const tagsWithNames = [
-  'callback',
-  'class', 'constructor',
-  'constant', 'const',
-  'event',
-  'external', 'host',
-  'function', 'func', 'method',
-  'interface',
-  'member', 'var',
-  'mixin',
-  'name',
-  'namespace',
-  'type',
-  'typedef'
-];
 
 export default iterateJsdoc(({
   context,
   jsdoc,
   report,
-  sourceCode
+  sourceCode,
+  utils
 }) => {
   const scopeManager = sourceCode.scopeManager;
   const globalScope = scopeManager.globalScope;
@@ -38,7 +24,7 @@ export default iterateJsdoc(({
     .map(parseComment)
     .flatMap((doc) => {
       return (doc.tags || []).filter(({tag}) => {
-        return tagsWithNames.includes(tag);
+        return utils.isNamepathDefiningTag(tag);
       });
     })
     .map((tag) => {

src/rules/validTypes.js

@@ -42,7 +42,7 @@ export default iterateJsdoc(({
 
         validTypeParsing(thatNamepath);
       }
-    } else if (utils.isNamepathType(tag.tag)) {
+    } else if (utils.isNamepathTag(tag.tag)) {
       if (utils.passesEmptyNamepathCheck(tag)) {
         return;
       }