From fb5e8c611083c92f9744847957d2014d65025e6b Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Thu, 7 Sep 2017 16:37:13 -0700
Subject: [PATCH] Fix forEachChild's visit of JSDocTypedefTag

Also remove JSDocTypeLiteral.jsdocTypeTag, which made no sense since it
was only useful when storing information for its parent `@typedef` tag.
---
 src/compiler/parser.ts | 16 +++++++++-------
 src/compiler/types.ts  |  1 -
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index b0782b6707..f81254572b 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -438,8 +438,10 @@ namespace ts {
                         visitNode(cbNode, (<JSDocTypedefTag>node).typeExpression);
                 }
             case SyntaxKind.JSDocTypeLiteral:
-                for (const tag of (node as JSDocTypeLiteral).jsDocPropertyTags) {
-                    visitNode(cbNode, tag);
+                if ((node as JSDocTypeLiteral).jsDocPropertyTags) {
+                    for (const tag of (node as JSDocTypeLiteral).jsDocPropertyTags) {
+                        visitNode(cbNode, tag);
+                    }
                 }
                 return;
             case SyntaxKind.PartiallyEmittedExpression:
@@ -6672,19 +6674,18 @@ namespace ts {
                     if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) {
                         let child: JSDocTypeTag | JSDocPropertyTag | false;
                         let jsdocTypeLiteral: JSDocTypeLiteral;
-                        let alreadyHasTypeTag = false;
+                        let childTypeTag: JSDocTypeTag;
                         const start = scanner.getStartPos();
                         while (child = tryParse(() => parseChildParameterOrPropertyTag(PropertyLikeParse.Property))) {
                             if (!jsdocTypeLiteral) {
                                 jsdocTypeLiteral = <JSDocTypeLiteral>createNode(SyntaxKind.JSDocTypeLiteral, start);
                             }
                             if (child.kind === SyntaxKind.JSDocTypeTag) {
-                                if (alreadyHasTypeTag) {
+                                if (childTypeTag) {
                                     break;
                                 }
                                 else {
-                                    jsdocTypeLiteral.jsDocTypeTag = child;
-                                    alreadyHasTypeTag = true;
+                                    childTypeTag = child;
                                 }
                             }
                             else {
@@ -6698,7 +6699,8 @@ namespace ts {
                             if (typeExpression && typeExpression.type.kind === SyntaxKind.ArrayType) {
                                 jsdocTypeLiteral.isArrayType = true;
                             }
-                            typedefTag.typeExpression = finishNode(jsdocTypeLiteral);
+                            const useChildTypeTagAsType = childTypeTag && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type);
+                            typedefTag.typeExpression = useChildTypeTagAsType ? childTypeTag.typeExpression : finishNode(jsdocTypeLiteral);
                         }
                     }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 55baf9763c..3a3736a5ce 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2211,7 +2211,6 @@ namespace ts {
     export interface JSDocTypeLiteral extends JSDocType {
         kind: SyntaxKind.JSDocTypeLiteral;
         jsDocPropertyTags?: ReadonlyArray<JSDocPropertyLikeTag>;
-        jsDocTypeTag?: JSDocTypeTag;
         /** If true, then this type literal represents an *array* of its type. */
         isArrayType?: boolean;
     }