diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d825b0d9717..c034f12b2b7 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -22340,6 +22340,7 @@ namespace ts {
                         break;
                     case SyntaxKind.MethodSignature:
                     case SyntaxKind.CallSignature:
+                    case SyntaxKind.JSDocSignature:
                     case SyntaxKind.ConstructSignature:
                     case SyntaxKind.FunctionType:
                     case SyntaxKind.ConstructorType:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 32e7ca19dd3..9f60d2ee85e 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -489,6 +489,15 @@ namespace ts {
                     return visitNode(cbNode, (<JSDocTypedefTag>node).fullName) ||
                         visitNode(cbNode, (<JSDocTypedefTag>node).typeExpression);
                 }
+            case SyntaxKind.JSDocCallbackTag:
+                return visitNode(cbNode, (node as JSDocCallbackTag).fullName) ||
+                    visitNode(cbNode, (node as JSDocCallbackTag).signature);
+            case SyntaxKind.JSDocSignature:
+                return visitNodes(cbNode, cbNodes, node.decorators) ||
+                    visitNodes(cbNode, cbNodes, node.modifiers) ||
+                    visitNodes(cbNode, cbNodes, (<SignatureDeclaration>node).typeParameters) ||
+                    visitNodes(cbNode, cbNodes, (<SignatureDeclaration>node).parameters) ||
+                    visitNode(cbNode, (<SignatureDeclaration>node).type);
             case SyntaxKind.JSDocTypeLiteral:
                 if ((node as JSDocTypeLiteral).jsDocPropertyTags) {
                     for (const tag of (node as JSDocTypeLiteral).jsDocPropertyTags) {
@@ -6457,6 +6466,9 @@ namespace ts {
                             case "typedef":
                                 tag = parseTypedefTag(atToken, tagName);
                                 break;
+                            case "callback":
+                                tag = parseCallbackTag(atToken, tagName);
+                                break;
                             default:
                                 tag = parseUnknownTag(atToken, tagName);
                                 break;
@@ -6710,6 +6722,14 @@ namespace ts {
                     return finishNode(tag);
                 }
 
+                function parseCallbackTag(atToken: AtToken, tagName: Identifier): JSDocCallbackTag {
+                    const callbackTag = createNode(SyntaxKind.JSDocCallbackTag, atToken.pos) as JSDocCallbackTag;
+                    callbackTag.atToken = atToken;
+                    callbackTag.tagName = tagName;
+                    callbackTag.fullName = parseJSDocTypeNameWithNamespace(/*flags*/ 0);
+                    return callbackTag;
+                }
+
                 function parseTypedefTag(atToken: AtToken, tagName: Identifier): JSDocTypedefTag {
                     const typeExpression = tryParseTypeExpression();
                     skipWhitespace();
@@ -6765,24 +6785,24 @@ namespace ts {
                     }
 
                     return finishNode(typedefTag);
+                }
 
-                    function parseJSDocTypeNameWithNamespace(flags: NodeFlags) {
-                        const pos = scanner.getTokenPos();
-                        const typeNameOrNamespaceName = parseJSDocIdentifierName();
+                function parseJSDocTypeNameWithNamespace(flags: NodeFlags) {
+                    const pos = scanner.getTokenPos();
+                    const typeNameOrNamespaceName = parseJSDocIdentifierName();
 
-                        if (typeNameOrNamespaceName && parseOptional(SyntaxKind.DotToken)) {
-                            const jsDocNamespaceNode = <JSDocNamespaceDeclaration>createNode(SyntaxKind.ModuleDeclaration, pos);
-                            jsDocNamespaceNode.flags |= flags;
-                            jsDocNamespaceNode.name = typeNameOrNamespaceName;
-                            jsDocNamespaceNode.body = parseJSDocTypeNameWithNamespace(NodeFlags.NestedNamespace);
-                            return finishNode(jsDocNamespaceNode);
-                        }
-
-                        if (typeNameOrNamespaceName && flags & NodeFlags.NestedNamespace) {
-                            typeNameOrNamespaceName.isInJSDocNamespace = true;
-                        }
-                        return typeNameOrNamespaceName;
+                    if (typeNameOrNamespaceName && parseOptional(SyntaxKind.DotToken)) {
+                        const jsDocNamespaceNode = <JSDocNamespaceDeclaration>createNode(SyntaxKind.ModuleDeclaration, pos);
+                        jsDocNamespaceNode.flags |= flags;
+                        jsDocNamespaceNode.name = typeNameOrNamespaceName;
+                        jsDocNamespaceNode.body = parseJSDocTypeNameWithNamespace(NodeFlags.NestedNamespace);
+                        return finishNode(jsDocNamespaceNode);
                     }
+
+                    if (typeNameOrNamespaceName && flags & NodeFlags.NestedNamespace) {
+                        typeNameOrNamespaceName.isInJSDocNamespace = true;
+                    }
+                    return typeNameOrNamespaceName;
                 }
 
                 function escapedTextsEqual(a: EntityName, b: EntityName): boolean {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 04db855d4f8..b98582e982a 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -509,6 +509,7 @@ namespace ts {
     export function isDeclarationWithTypeParameters(node: DeclarationWithTypeParameters): node is DeclarationWithTypeParameters {
         switch (node.kind) {
             case SyntaxKind.CallSignature:
+            case SyntaxKind.JSDocSignature:
             case SyntaxKind.ConstructSignature:
             case SyntaxKind.MethodSignature:
             case SyntaxKind.IndexSignature: