Merge pull request microsoft#12442 from RyanCavanaugh/portAugments

RyanCavanaugh · web-flow · commit fb23e6dba1e7 · 2016-11-22T11:52:18.000-08:00
Port augments to 2.1
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3797,6 +3797,16 @@ namespace ts {
                 }
                 baseType = getReturnTypeOfSignature(constructors[0]);
             }
+
+            // In a JS file, you can use the @augments jsdoc tag to specify a base type with type parameters
+            const valueDecl = type.symbol.valueDeclaration;
+            if (valueDecl && isInJavaScriptFile(valueDecl)) {
+                const augTag = getJSDocAugmentsTag(type.symbol.valueDeclaration);
+                if (augTag) {
+                    baseType = getTypeFromTypeNode(augTag.typeExpression.type);
+                }
+            }
+
             if (baseType === unknownType) {
                 return;
             }
@@ -3805,7 +3815,7 @@ namespace ts {
                 return;
             }
             if (type === baseType || hasBaseType(<InterfaceType>baseType, type)) {
-                error(type.symbol.valueDeclaration, Diagnostics.Type_0_recursively_references_itself_as_a_base_type,
+                error(valueDecl, Diagnostics.Type_0_recursively_references_itself_as_a_base_type,
                     typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
                 return;
             }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -418,6 +418,8 @@ namespace ts {
                 return visitNode(cbNode, (<JSDocReturnTag>node).typeExpression);
             case SyntaxKind.JSDocTypeTag:
                 return visitNode(cbNode, (<JSDocTypeTag>node).typeExpression);
+            case SyntaxKind.JSDocAugmentsTag:
+                return visitNode(cbNode, (<JSDocAugmentsTag>node).typeExpression);
             case SyntaxKind.JSDocTemplateTag:
                 return visitNodes(cbNodes, (<JSDocTemplateTag>node).typeParameters);
             case SyntaxKind.JSDocTypedefTag:
@@ -6426,6 +6428,9 @@ namespace ts {
                     let tag: JSDocTag;
                     if (tagName) {
                         switch (tagName.text) {
+                            case "augments":
+                                tag = parseAugmentsTag(atToken, tagName);
+                                break;
                             case "param":
                                 tag = parseParamTag(atToken, tagName);
                                 break;
@@ -6642,6 +6647,16 @@ namespace ts {
                     return finishNode(result);
                 }
 
+                function parseAugmentsTag(atToken: AtToken, tagName: Identifier): JSDocAugmentsTag {
+                    const typeExpression = tryParseTypeExpression();
+
+                    const result = <JSDocAugmentsTag>createNode(SyntaxKind.JSDocAugmentsTag, atToken.pos);
+                    result.atToken = atToken;
+                    result.tagName = tagName;
+                    result.typeExpression = typeExpression;
+                    return finishNode(result);
+                }
+
                 function parseTypedefTag(atToken: AtToken, tagName: Identifier): JSDocTypedefTag {
                     const typeExpression = tryParseTypeExpression();
                     skipWhitespace();
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -349,6 +349,7 @@ namespace ts {
         JSDocThisType,
         JSDocComment,
         JSDocTag,
+        JSDocAugmentsTag,
         JSDocParameterTag,
         JSDocReturnTag,
         JSDocTypeTag,
@@ -1989,6 +1990,11 @@ namespace ts {
         kind: SyntaxKind.JSDocTag;
     }
 
+    export interface JSDocAugmentsTag extends JSDocTag {
+        kind: SyntaxKind.JSDocAugmentsTag;
+        typeExpression: JSDocTypeExpression;
+    }
+
     export interface JSDocTemplateTag extends JSDocTag {
         kind: SyntaxKind.JSDocTemplateTag;
         typeParameters: NodeArray<TypeParameterDeclaration>;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -1539,6 +1539,10 @@ namespace ts {
         return tag && tag.typeExpression && tag.typeExpression.type;
     }
 
+    export function getJSDocAugmentsTag(node: Node): JSDocAugmentsTag {
+        return getFirstJSDocTag(node, SyntaxKind.JSDocAugmentsTag) as JSDocAugmentsTag;
+    }
+
     export function getJSDocReturnTag(node: Node): JSDocReturnTag {
         return getFirstJSDocTag(node, SyntaxKind.JSDocReturnTag) as JSDocReturnTag;
     }
diff --git a/tests/cases/fourslash/jsDocAugments.ts b/tests/cases/fourslash/jsDocAugments.ts
@@ -0,0 +1,23 @@
+///<reference path="fourslash.ts" />
+
+// @allowJs: true
+// @Filename: dummy.js
+
+//// /**
+////  * @augments {Thing<string>}
+////  */
+//// class MyStringThing extends Thing {
+////     constructor() {
+////         var x = this.mine;
+////         x/**/;
+////     }
+//// }
+
+// @Filename: declarations.d.ts
+//// declare class Thing<T> {
+////     mine: T;    
+//// }
+
+goTo.marker();
+verify.quickInfoIs("(local var) x: string");
+

Original file line number	Diff line number	Diff line change
`@@ -3797,6 +3797,16 @@ namespace ts {`
`3797`	`3797`	`}`
`3798`	`3798`	`baseType = getReturnTypeOfSignature(constructors[0]);`
`3799`	`3799`	`}`
	`3800`	`+`
	`3801`	`+ // In a JS file, you can use the @augments jsdoc tag to specify a base type with type parameters`
	`3802`	`+ const valueDecl = type.symbol.valueDeclaration;`
	`3803`	`+ if (valueDecl && isInJavaScriptFile(valueDecl)) {`
	`3804`	`+ const augTag = getJSDocAugmentsTag(type.symbol.valueDeclaration);`
	`3805`	`+ if (augTag) {`
	`3806`	`+ baseType = getTypeFromTypeNode(augTag.typeExpression.type);`
	`3807`	`+ }`
	`3808`	`+ }`
	`3809`	`+`
`3800`	`3810`	`if (baseType === unknownType) {`
`3801`	`3811`	`return;`
`3802`	`3812`	`}`
`@@ -3805,7 +3815,7 @@ namespace ts {`
`3805`	`3815`	`return;`
`3806`	`3816`	`}`
`3807`	`3817`	`if (type === baseType \|\| hasBaseType(<InterfaceType>baseType, type)) {`
`3808`		`- error(type.symbol.valueDeclaration, Diagnostics.Type_0_recursively_references_itself_as_a_base_type,`
	`3818`	`+ error(valueDecl, Diagnostics.Type_0_recursively_references_itself_as_a_base_type,`
`3809`	`3819`	`typeToString(type, /enclosingDeclaration/ undefined, TypeFormatFlags.WriteArrayAsGenericType));`
`3810`	`3820`	`return;`
`3811`	`3821`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1539,6 +1539,10 @@ namespace ts {`
`1539`	`1539`	`return tag && tag.typeExpression && tag.typeExpression.type;`
`1540`	`1540`	`}`
`1541`	`1541`
	`1542`	`+ export function getJSDocAugmentsTag(node: Node): JSDocAugmentsTag {`
	`1543`	`+ return getFirstJSDocTag(node, SyntaxKind.JSDocAugmentsTag) as JSDocAugmentsTag;`
	`1544`	`+ }`
	`1545`	`+`
`1542`	`1546`	`export function getJSDocReturnTag(node: Node): JSDocReturnTag {`
`1543`	`1547`	`return getFirstJSDocTag(node, SyntaxKind.JSDocReturnTag) as JSDocReturnTag;`
`1544`	`1548`	`}`