function checkTag()

in src/rules/noRedundantJsdoc2Rule.ts [61:131]
58 lines of code
30 McCabe index (conditional complexity)

    function checkTag(tag: ts.JSDocTag): void {
        const jsdocSeeTag = (ts.SyntaxKind as any).JSDocSeeTag || 0;
        const jsdocDeprecatedTag = (ts.SyntaxKind as any).JSDocDeprecatedTag || 0;
        switch (tag.kind) {
            case jsdocSeeTag:
            case jsdocDeprecatedTag:
            case ts.SyntaxKind.JSDocAuthorTag:
                // @deprecated and @see always have meaning
                break;
            case ts.SyntaxKind.JSDocTag: {
                const { tagName } = tag;
                const { text } = tagName;
                // Allow "default" in an ambient context (since you can't write an initializer in an ambient context)
                if (redundantTags.has(text) && !(text === "default" && isInAmbientContext(tag))) {
                    ctx.addFailureAtNode(tagName, Rule.FAILURE_STRING_REDUNDANT_TAG(text), removeTag(tag, sourceFile));
                }
                break;
            }

            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
            // @ts-ignore (fallthrough)
            case ts.SyntaxKind.JSDocTemplateTag:
                if (tag.comment !== "") {
                    break;
                }
                // falls through

            case ts.SyntaxKind.JSDocPublicTag:
            case ts.SyntaxKind.JSDocPrivateTag:
            case ts.SyntaxKind.JSDocProtectedTag:
            case ts.SyntaxKind.JSDocClassTag:
            case ts.SyntaxKind.JSDocTypeTag:
            case ts.SyntaxKind.JSDocTypedefTag:
            case ts.SyntaxKind.JSDocReadonlyTag:
            case ts.SyntaxKind.JSDocPropertyTag:
            case ts.SyntaxKind.JSDocAugmentsTag:
            case ts.SyntaxKind.JSDocImplementsTag:
            case ts.SyntaxKind.JSDocCallbackTag:
            case ts.SyntaxKind.JSDocThisTag:
            case ts.SyntaxKind.JSDocEnumTag:

                // Always redundant
                ctx.addFailureAtNode(
                    tag.tagName,
                    Rule.FAILURE_STRING_REDUNDANT_TAG(tag.tagName.text),
                    removeTag(tag, sourceFile));
                break;

            case ts.SyntaxKind.JSDocReturnTag:
            case ts.SyntaxKind.JSDocParameterTag: {
                const { typeExpression, comment } = tag as ts.JSDocReturnTag | ts.JSDocParameterTag;
                const noComment = comment === "";
                if (typeExpression !== undefined) {
                    // If noComment, we will just completely remove it in the other fix
                    const fix = noComment ? undefined : removeTypeExpression(typeExpression, sourceFile);
                    ctx.addFailureAtNode(typeExpression, Rule.FAILURE_STRING_REDUNDANT_TYPE, fix);
                }
                if (noComment) {
                    // Redundant if no documentation
                    ctx.addFailureAtNode(
                        tag.tagName,
                        Rule.FAILURE_STRING_NO_COMMENT(tag.tagName.text),
                        removeTag(tag, sourceFile));
                }
                break;
            }

            default:
                throw new Error(`Unexpected tag kind: ${ts.SyntaxKind[tag.kind]}`);
        }
    }