Merge pull request #18333 from Microsoft/fix-forEachChild-JSDocTypedefTag

sandersn · web-flow · commit d4e3e19763e0 · 2017-09-08T08:52:46.000-07:00
Fix forEachChild jsdoc `@typedef` tag
diff --git 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:
@@ -6652,19 +6654,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 {
@@ -6678,7 +6679,9 @@ namespace ts {
                             if (typeExpression && typeExpression.type.kind === SyntaxKind.ArrayType) {
                                 jsdocTypeLiteral.isArrayType = true;
                             }
-                            typedefTag.typeExpression = finishNode(jsdocTypeLiteral);
+                            typedefTag.typeExpression = childTypeTag && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
+                                childTypeTag.typeExpression :
+                                finishNode(jsdocTypeLiteral);
                         }
                     }
 
diff --git 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;
     }
diff --git a/tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.typedefTagWithChildrenTags.json b/tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.typedefTagWithChildrenTags.json
@@ -34,38 +34,6 @@
                 "kind": "JSDocTypeLiteral",
                 "pos": 26,
                 "end": 98,
-                "jsDocTypeTag": {
-                    "kind": "JSDocTypeTag",
-                    "pos": 28,
-                    "end": 42,
-                    "atToken": {
-                        "kind": "AtToken",
-                        "pos": 28,
-                        "end": 29
-                    },
-                    "tagName": {
-                        "kind": "Identifier",
-                        "pos": 29,
-                        "end": 33,
-                        "escapedText": "type"
-                    },
-                    "typeExpression": {
-                        "kind": "JSDocTypeExpression",
-                        "pos": 34,
-                        "end": 42,
-                        "type": {
-                            "kind": "TypeReference",
-                            "pos": 35,
-                            "end": 41,
-                            "typeName": {
-                                "kind": "Identifier",
-                                "pos": 35,
-                                "end": 41,
-                                "escapedText": "Object"
-                            }
-                        }
-                    }
-                },
                 "jsDocPropertyTags": [
                     {
                         "kind": "JSDocPropertyTag",
diff --git a/tests/baselines/reference/jsdocTwoLineTypedef.js b/tests/baselines/reference/jsdocTwoLineTypedef.js
@@ -0,0 +1,10 @@
+//// [jsdocTwoLineTypedef.ts]
+// Regression from #18301
+/**
+ * @typedef LoadCallback
+ * @type {function}
+ */
+type LoadCallback = void;
+
+
+//// [jsdocTwoLineTypedef.js]
diff --git a/tests/baselines/reference/jsdocTwoLineTypedef.symbols b/tests/baselines/reference/jsdocTwoLineTypedef.symbols
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/jsdoc/jsdocTwoLineTypedef.ts ===
+// Regression from #18301
+/**
+ * @typedef LoadCallback
+ * @type {function}
+ */
+type LoadCallback = void;
+>LoadCallback : Symbol(LoadCallback, Decl(jsdocTwoLineTypedef.ts, 0, 0))
+
diff --git a/tests/baselines/reference/jsdocTwoLineTypedef.types b/tests/baselines/reference/jsdocTwoLineTypedef.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/jsdoc/jsdocTwoLineTypedef.ts ===
+// Regression from #18301
+/**
+ * @typedef LoadCallback
+ * @type {function}
+ */
+type LoadCallback = void;
+>LoadCallback : void
+
diff --git a/tests/cases/conformance/jsdoc/jsdocTwoLineTypedef.ts b/tests/cases/conformance/jsdoc/jsdocTwoLineTypedef.ts
@@ -0,0 +1,6 @@
+// Regression from #18301
+/**
+ * @typedef LoadCallback
+ * @type {function}
+ */
+type LoadCallback = void;

Original file line number	Diff line number	Diff line change
`@@ -438,8 +438,10 @@ namespace ts {`
`438`	`438`	`visitNode(cbNode, (<JSDocTypedefTag>node).typeExpression);`
`439`	`439`	`}`
`440`	`440`	`case SyntaxKind.JSDocTypeLiteral:`
`441`		`- for (const tag of (node as JSDocTypeLiteral).jsDocPropertyTags) {`
`442`		`- visitNode(cbNode, tag);`
	`441`	`+ if ((node as JSDocTypeLiteral).jsDocPropertyTags) {`
	`442`	`+ for (const tag of (node as JSDocTypeLiteral).jsDocPropertyTags) {`
	`443`	`+ visitNode(cbNode, tag);`
	`444`	`+ }`
`443`	`445`	`}`
`444`	`446`	`return;`
`445`	`447`	`case SyntaxKind.PartiallyEmittedExpression:`
`@@ -6652,19 +6654,18 @@ namespace ts {`
`6652`	`6654`	`if (!typeExpression \|\| isObjectOrObjectArrayTypeReference(typeExpression.type)) {`
`6653`	`6655`	`let child: JSDocTypeTag \| JSDocPropertyTag \| false;`
`6654`	`6656`	`let jsdocTypeLiteral: JSDocTypeLiteral;`
`6655`		`- let alreadyHasTypeTag = false;`
	`6657`	`+ let childTypeTag: JSDocTypeTag;`
`6656`	`6658`	`const start = scanner.getStartPos();`
`6657`	`6659`	`while (child = tryParse(() => parseChildParameterOrPropertyTag(PropertyLikeParse.Property))) {`
`6658`	`6660`	`if (!jsdocTypeLiteral) {`
`6659`	`6661`	`jsdocTypeLiteral = <JSDocTypeLiteral>createNode(SyntaxKind.JSDocTypeLiteral, start);`
`6660`	`6662`	`}`
`6661`	`6663`	`if (child.kind === SyntaxKind.JSDocTypeTag) {`
`6662`		`- if (alreadyHasTypeTag) {`
	`6664`	`+ if (childTypeTag) {`
`6663`	`6665`	`break;`
`6664`	`6666`	`}`
`6665`	`6667`	`else {`
`6666`		`- jsdocTypeLiteral.jsDocTypeTag = child;`
`6667`		`- alreadyHasTypeTag = true;`
	`6668`	`+ childTypeTag = child;`
`6668`	`6669`	`}`
`6669`	`6670`	`}`
`6670`	`6671`	`else {`
`@@ -6678,7 +6679,9 @@ namespace ts {`
`6678`	`6679`	`if (typeExpression && typeExpression.type.kind === SyntaxKind.ArrayType) {`
`6679`	`6680`	`jsdocTypeLiteral.isArrayType = true;`
`6680`	`6681`	`}`
`6681`		`- typedefTag.typeExpression = finishNode(jsdocTypeLiteral);`
	`6682`	`+ typedefTag.typeExpression = childTypeTag && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?`
	`6683`	`+ childTypeTag.typeExpression :`
	`6684`	`+ finishNode(jsdocTypeLiteral);`
`6682`	`6685`	`}`
`6683`	`6686`	`}`
`6684`	`6687`
Original file line number	Diff line number	Diff line change
`@@ -2211,7 +2211,6 @@ namespace ts {`
`2211`	`2211`	`export interface JSDocTypeLiteral extends JSDocType {`
`2212`	`2212`	`kind: SyntaxKind.JSDocTypeLiteral;`
`2213`	`2213`	`jsDocPropertyTags?: ReadonlyArray<JSDocPropertyLikeTag>;`
`2214`		`- jsDocTypeTag?: JSDocTypeTag;`
`2215`	`2214`	`/** If true, then this type literal represents an array of its type. */`
`2216`	`2215`	`isArrayType?: boolean;`
`2217`	`2216`	`}`