Incorporated feedback

Author: kraenhansen

docs/rules/no-undefined-types.md

@@ -247,20 +247,12 @@ function quux () {}
 // Message: The type 'SomeType' is undefined.
 
 /**
- * @namepathDefiner SomeType
- */
-/**
- * @type {SomeType}
- */
-// Settings: {"jsdoc":{"structuredTags":{"namepathDefiner":{"name":"namepath-referencing"}}}}
-// Message: The type 'SomeType' is undefined.
-
-/**
- * @namepathDefiner SomeType
+ * @namepathReferencing SomeType
  */
 /**
  * @type {SomeType}
  */
+// Settings: {"jsdoc":{"structuredTags":{"namepathReferencing":{"name":"namepath-referencing"}}}}
 // Message: The type 'SomeType' is undefined.
 
 /**

src/getDefaultTagStructureForMode.js

@@ -11,7 +11,7 @@ const getDefaultTagStructureForMode = (mode) => {
   const isJsdocTypescriptOrPermissive = isJsdocOrTypescript || isPermissive;
 
   // Properties:
-  // `nameContents` - 'namepath-referencing'|'namepath-defining'|'text'|false
+  // `nameContents` - 'namepath-referencing'|'namepath-defining'|'namepath-or-url-referencing'|'text'|false
   // `typeAllowed` - boolean
   // `nameRequired` - boolean
   // `typeRequired` - boolean
@@ -463,13 +463,9 @@ const getDefaultTagStructureForMode = (mode) => {
       'link', new Map([
         // Signature seems to require a namepath OR URL and might be checked as such.
         [
-          'nameContents', 'namepath-referencing',
+          'nameContents', 'namepath-or-url-referencing',
         ],
 
-        // "namepath"
-        [
-          'typeOrNameRequired', true,
-        ],
       ]),
     ],
 
@@ -478,12 +474,7 @@ const getDefaultTagStructureForMode = (mode) => {
         // Synonym for "link"
         // Signature seems to require a namepath OR URL and might be checked as such.
         [
-          'nameContents', 'namepath-referencing',
-        ],
-
-        // "namepath"
-        [
-          'typeOrNameRequired', true,
+          'nameContents', 'namepath-or-url-referencing',
         ],
       ]),
     ],
@@ -493,12 +484,7 @@ const getDefaultTagStructureForMode = (mode) => {
         // Synonym for "link"
         // Signature seems to require a namepath OR URL and might be checked as such.
         [
-          'nameContents', 'namepath-referencing',
-        ],
-
-        // "namepath"
-        [
-          'typeOrNameRequired', true,
+          'nameContents', 'namepath-or-url-referencing',
         ],
       ]),
     ],

src/iterateJsdoc.js

@@ -769,7 +769,6 @@ const getUtils = (
   for (const method of [
     'tagMightHaveNamePosition',
     'tagMightHaveTypePosition',
-    'tagMightHaveEitherTypeOrNamePosition',
   ]) {
     utils[method] = (tagName, otherModeMaps) => {
       const result = jsdocUtils[method](tagName);
@@ -816,6 +815,8 @@ const getUtils = (
 
   for (const method of [
     'isNamepathDefiningTag',
+    'isNamepathReferencingTag',
+    'isNamepathOrUrlReferencingTag',
     'tagMightHaveNamepath',
   ]) {
     utils[method] = (tagName) => {
@@ -869,8 +870,9 @@ const getUtils = (
     });
   };
 
-  utils.filterTags = (filter) => {
-    return jsdocUtils.filterTags(jsdocUtils.getAllTags(jsdoc), filter);
+  utils.filterTags = (filter, includeInlineTags = false) => {
+    const tags = jsdocUtils.getAllTags(jsdoc, includeInlineTags);
+    return jsdocUtils.filterTags(tags, filter);
   };
 
   utils.getTagsByType = (tags) => {

src/jsdocUtils.js

@@ -458,14 +458,14 @@ const hasTag = (jsdoc, targetTagName) => {
  * @param {object} jsdoc
  * @returns {Array}
  */
-const getAllTags = (jsdoc) => {
-  return [
+const getAllTags = (jsdoc, includeInlineTags = false) => {
+  return includeInlineTags ? [
     ...jsdoc.tags,
     ...jsdoc.inlineTags,
     ...jsdoc.tags.flatMap((tag) => {
       return tag.inlineTags;
     }),
-  ];
+  ] : jsdoc.tags;
 };
 
 /**
@@ -618,6 +618,26 @@ const isNamepathDefiningTag = (tag, tagMap = tagStructure) => {
   return tagStruct.get('nameContents') === 'namepath-defining';
 };
 
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+const isNamepathReferencingTag = (tag, tagMap = tagStructure) => {
+  const tagStruct = ensureMap(tagMap, tag);
+  return tagStruct.get('nameContents') === 'namepath-referencing';
+};
+
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+const isNamepathOrUrlReferencingTag = (tag, tagMap = tagStructure) => {
+  const tagStruct = ensureMap(tagMap, tag);
+  return tagStruct.get('nameContents') === 'namepath-or-url-referencing';
+};
+
 /**
  * @param tag
  * @param {Map} tagMap
@@ -1267,6 +1287,8 @@ export default {
   isConstructor,
   isGetter,
   isNamepathDefiningTag,
+  isNamepathOrUrlReferencingTag,
+  isNamepathReferencingTag,
   isSetter,
   isValidTag,
   mayBeUndefinedTypeTag,

src/rules/noUndefinedTypes.js

@@ -186,24 +186,48 @@ export default iterateJsdoc(({
         ],
     ));
 
-  const jsdocTagsWithPossibleType = utils.filterTags(({
-    tag,
-  }) => {
-    return utils.tagMightHaveEitherTypeOrNamePosition(tag) && (tag !== 'suppress' || settings.mode !== 'closure');
-  });
-
-  for (const tag of jsdocTagsWithPossibleType) {
-    const possibleType = tag.type || tag.name || tag.namepathOrURL;
-
-    let parsedType;
+  const tagToParsedType = (propertyName) => {
+    return (tag) => {
+      try {
+        const potentialType = tag[propertyName];
+        return {
+          parsedType: mode === 'permissive' ? tryParseType(potentialType) : parseType(potentialType, mode),
+          tag,
+        };
+      } catch {
+        return undefined;
+      }
+    };
+  };
 
-    try {
-      parsedType = mode === 'permissive' ? tryParseType(possibleType) : parseType(possibleType, mode);
-    } catch {
-      // On syntax error, will be handled by valid-types.
-      continue;
-    }
+  const tagsWithTypes = [
+    // Tags with type
+    ...utils.filterTags(({
+      tag,
+    }) => {
+      return utils.tagMightHaveTypePosition(tag) && (tag !== 'suppress' || settings.mode !== 'closure');
+    }).map(tagToParsedType('type')),
+    // Tags with namepaths
+    ...utils.filterTags(({
+      tag,
+    }) => {
+      return utils.isNamepathReferencingTag(tag) && (tag !== 'suppress' || settings.mode !== 'closure');
+    }).map(tagToParsedType('name')),
+    // Inline tags
+    ...utils.filterTags(({
+      tag,
+    }) => {
+      return utils.isNamepathOrUrlReferencingTag(tag) && (tag !== 'suppress' || settings.mode !== 'closure');
+    }, true).map(tagToParsedType('namepathOrURL')),
+  ].filter((result) => {
+    // Remove types which failed to parse
+    return result;
+  });
 
+  for (const {
+    tag,
+    parsedType,
+  } of tagsWithTypes) {
     traverse(parsedType, ({
       type,
       value,

test/rules/assertions/noUndefinedTypes.js

@@ -380,7 +380,7 @@ export default {
     {
       code: `
       /**
-       * @namepathDefiner SomeType
+       * @namepathReferencing SomeType
        */
       /**
        * @type {SomeType}
@@ -399,32 +399,31 @@ export default {
       settings: {
         jsdoc: {
           structuredTags: {
-            namepathDefiner: {
+            namepathReferencing: {
               name: 'namepath-referencing',
             },
           },
         },
       },
     },
     {
+      // An unknown tag without an namepath contents declared via settings,
+      // defaults to not having an impact on the type.
       code: `
       /**
-       * @namepathDefiner SomeType
+       * @namepathMentioning SomeType
        */
       /**
        * @type {SomeType}
        */
       `,
       errors: [
-        {
-          line: 3,
-          message: 'The type \'SomeType\' is undefined.',
-        },
         {
           line: 6,
           message: 'The type \'SomeType\' is undefined.',
         },
       ],
+      ignoreReadme: true,
     },
     {
       code: `