Use jsdoc aliases if visible when printing types (#24153)

weswigham · web-flow · commit 5bf6e30f8e83 · 2018-05-16T12:58:36.000-07:00
* Use jsdoc aliases if visible when printing types

* Modify implementation a bit, add test that aughta change in the new future

* Accept baselines- hold off on typedef template lookup change
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -4024,6 +4024,10 @@ namespace ts {
 
             function determineIfDeclarationIsVisible() {
                 switch (node.kind) {
+                    case SyntaxKind.JSDocTypedefTag:
+                        // Top-level jsdoc typedefs are considered exported
+                        // First parent is comment node, second is hosting declaration or token; we only care about those tokens or declarations whose parent is a source file
+                        return !!(node.parent && node.parent.parent && node.parent.parent.parent && isSourceFile(node.parent.parent.parent));
                     case SyntaxKind.BindingElement:
                         return isDeclarationVisible(node.parent.parent);
                     case SyntaxKind.VariableDeclaration:
@@ -5163,8 +5167,8 @@ namespace ts {
             let result: TypeParameter[];
             for (const node of symbol.declarations) {
                 if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration ||
-                    node.kind === SyntaxKind.ClassExpression || node.kind === SyntaxKind.TypeAliasDeclaration) {
-                    const declaration = <InterfaceDeclaration | TypeAliasDeclaration>node;
+                    node.kind === SyntaxKind.ClassExpression || node.kind === SyntaxKind.TypeAliasDeclaration || node.kind === SyntaxKind.JSDocTypedefTag) {
+                    const declaration = <InterfaceDeclaration | TypeAliasDeclaration | JSDocTypedefTag>node;
                     const typeParameters = getEffectiveTypeParameterDeclarations(declaration);
                     if (typeParameters) {
                         result = appendTypeParameters(result, typeParameters);
@@ -9046,7 +9050,7 @@ namespace ts {
         }
 
         function getAliasSymbolForTypeNode(node: TypeNode) {
-            return node.parent.kind === SyntaxKind.TypeAliasDeclaration ? getSymbolOfNode(node.parent) : undefined;
+            return (node.parent.kind === SyntaxKind.TypeAliasDeclaration || node.parent.kind === SyntaxKind.JSDocTypedefTag) ? getSymbolOfNode(node.parent) : undefined;
         }
 
         function getAliasTypeArgumentsForTypeNode(node: TypeNode) {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3093,11 +3093,13 @@ namespace ts {
      * Gets the effective type parameters. If the node was parsed in a
      * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
      */
-    export function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters) {
-        return node.typeParameters || (isInJavaScriptFile(node) ? getJSDocTypeParameterDeclarations(node) : undefined);
+    export function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters | JSDocTypedefTag) {
+        return isJSDocTypedefTag(node)
+            ? getJSDocTypeParameterDeclarations(node)
+            : node.typeParameters || (isInJavaScriptFile(node) ? getJSDocTypeParameterDeclarations(node) : undefined);
     }
 
-    export function getJSDocTypeParameterDeclarations(node: DeclarationWithTypeParameters) {
+    export function getJSDocTypeParameterDeclarations(node: DeclarationWithTypeParameters | JSDocTypedefTag) {
         const templateTag = getJSDocTemplateTag(node);
         return templateTag && templateTag.typeParameters;
     }
diff --git a/tests/baselines/reference/checkJsdocTypedefInParamTag1.types b/tests/baselines/reference/checkJsdocTypedefInParamTag1.types
@@ -10,18 +10,18 @@
  * @param {Opts} opts
  */
 function foo(opts) {
->foo : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
->opts : { x: string; y?: string; z?: string; w?: string; }
+>foo : (opts: Opts) => void
+>opts : Opts
 
     opts.x;
 >opts.x : string
->opts : { x: string; y?: string; z?: string; w?: string; }
+>opts : Opts
 >x : string
 }
 
 foo({x: 'abc'});
 >foo({x: 'abc'}) : void
->foo : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
+>foo : (opts: Opts) => void
 >{x: 'abc'} : { x: string; }
 >x : string
 >'abc' : "abc"
@@ -34,18 +34,18 @@ foo({x: 'abc'});
  * @param {AnotherOpts} opts
  */
 function foo1(opts) {
->foo1 : (opts: { anotherX: string; anotherY?: string; }) => void
->opts : { anotherX: string; anotherY?: string; }
+>foo1 : (opts: AnotherOpts) => void
+>opts : AnotherOpts
 
     opts.anotherX;
 >opts.anotherX : string
->opts : { anotherX: string; anotherY?: string; }
+>opts : AnotherOpts
 >anotherX : string
 }
 
 foo1({anotherX: "world"});
 >foo1({anotherX: "world"}) : void
->foo1 : (opts: { anotherX: string; anotherY?: string; }) => void
+>foo1 : (opts: AnotherOpts) => void
 >{anotherX: "world"} : { anotherX: string; }
 >anotherX : string
 >"world" : "world"
@@ -60,17 +60,17 @@ foo1({anotherX: "world"});
  * @param {Opts1} opts
  */
 function foo2(opts) {
->foo2 : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
->opts : { x: string; y?: string; z?: string; w?: string; }
+>foo2 : (opts: Opts1) => void
+>opts : Opts1
 
     opts.x;
 >opts.x : string
->opts : { x: string; y?: string; z?: string; w?: string; }
+>opts : Opts1
 >x : string
 }
 foo2({x: 'abc'});
 >foo2({x: 'abc'}) : void
->foo2 : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
+>foo2 : (opts: Opts1) => void
 >{x: 'abc'} : { x: string; }
 >x : string
 >'abc' : "abc"
diff --git a/tests/baselines/reference/jsDocTypedef1.js b/tests/baselines/reference/jsDocTypedef1.js
@@ -41,140 +41,8 @@
           "kind": "space"
         },
         {
-          "text": "{",
-          "kind": "punctuation"
-        },
-        {
-          "text": "\n",
-          "kind": "lineBreak"
-        },
-        {
-          "text": "    ",
-          "kind": "space"
-        },
-        {
-          "text": "x",
-          "kind": "propertyName"
-        },
-        {
-          "text": ":",
-          "kind": "punctuation"
-        },
-        {
-          "text": " ",
-          "kind": "space"
-        },
-        {
-          "text": "string",
-          "kind": "keyword"
-        },
-        {
-          "text": ";",
-          "kind": "punctuation"
-        },
-        {
-          "text": "\n",
-          "kind": "lineBreak"
-        },
-        {
-          "text": "    ",
-          "kind": "space"
-        },
-        {
-          "text": "y",
-          "kind": "propertyName"
-        },
-        {
-          "text": "?",
-          "kind": "punctuation"
-        },
-        {
-          "text": ":",
-          "kind": "punctuation"
-        },
-        {
-          "text": " ",
-          "kind": "space"
-        },
-        {
-          "text": "string",
-          "kind": "keyword"
-        },
-        {
-          "text": ";",
-          "kind": "punctuation"
-        },
-        {
-          "text": "\n",
-          "kind": "lineBreak"
-        },
-        {
-          "text": "    ",
-          "kind": "space"
-        },
-        {
-          "text": "z",
-          "kind": "propertyName"
-        },
-        {
-          "text": "?",
-          "kind": "punctuation"
-        },
-        {
-          "text": ":",
-          "kind": "punctuation"
-        },
-        {
-          "text": " ",
-          "kind": "space"
-        },
-        {
-          "text": "string",
-          "kind": "keyword"
-        },
-        {
-          "text": ";",
-          "kind": "punctuation"
-        },
-        {
-          "text": "\n",
-          "kind": "lineBreak"
-        },
-        {
-          "text": "    ",
-          "kind": "space"
-        },
-        {
-          "text": "w",
-          "kind": "propertyName"
-        },
-        {
-          "text": "?",
-          "kind": "punctuation"
-        },
-        {
-          "text": ":",
-          "kind": "punctuation"
-        },
-        {
-          "text": " ",
-          "kind": "space"
-        },
-        {
-          "text": "string",
-          "kind": "keyword"
-        },
-        {
-          "text": ";",
-          "kind": "punctuation"
-        },
-        {
-          "text": "\n",
-          "kind": "lineBreak"
-        },
-        {
-          "text": "}",
-          "kind": "punctuation"
+          "text": "Opts",
+          "kind": "aliasName"
         }
       ],
       "documentation": [],
diff --git a/tests/baselines/reference/jsdocTemplateConstructorFunction2.types b/tests/baselines/reference/jsdocTemplateConstructorFunction2.types
@@ -79,7 +79,7 @@ z.u = false
  */
 /** @type {A} */
 const options = { value: null };
->options : { value: any; }
+>options : A
 >{ value: null } : { value: null; }
 >value : null
 >null : null
diff --git a/tests/baselines/reference/jsdocTypedefMissingType.types b/tests/baselines/reference/jsdocTypedefMissingType.types
@@ -14,7 +14,7 @@ const t = 0;
 
 /** @type Person */
 const person = { name: "" };
->person : { name: string; }
+>person : Person
 >{ name: "" } : { name: string; }
 >name : string
 >"" : ""
diff --git a/tests/baselines/reference/jsdocTypedef_propertyWithNoType.types b/tests/baselines/reference/jsdocTypedef_propertyWithNoType.types
@@ -6,7 +6,7 @@
 
 /** @type {Foo} */
 const x = { foo: 0 };
->x : { foo: any; }
+>x : Foo
 >{ foo: 0 } : { foo: number; }
 >foo : number
 >0 : 0
diff --git a/tests/baselines/reference/typedefTagNested.types b/tests/baselines/reference/typedefTagNested.types
@@ -10,7 +10,7 @@ var ex;
 
 /** @type {App} */
 const app = {
->app : { name: string; icons: { image32: string; image64: string; }; }
+>app : App
 >{    name: 'name',    icons: {        image32: 'x.png',        image64: 'y.png',    }} : { name: string; icons: { image32: string; image64: string; }; }
 
     name: 'name',
@@ -40,5 +40,5 @@ const app = {
 
 /** @type {Opp} */
 var mistake;
->mistake : { name: string; oops: { horrible: string; }; }
+>mistake : Opp
 
diff --git a/tests/cases/fourslash/jsQuickInfoGenerallyAcceptableSize.ts b/tests/cases/fourslash/jsQuickInfoGenerallyAcceptableSize.ts
