Fixed declaration emit for @interface

Author: dragomirtitian

src/compiler/checker.ts

@@ -5696,9 +5696,13 @@ namespace ts {
                     const typeParamDecls = map(localParams, p => typeParameterToDeclaration(p, context));
                     const classType = getDeclaredTypeOfClassOrInterface(symbol);
                     const baseTypes = getBaseTypes(classType);
+                    const implementsTypes = getImplementsTypes(classType);
                     const staticType = getTypeOfSymbol(symbol);
                     const staticBaseType = getBaseConstructorTypeOfClass(staticType as InterfaceType);
-                    const heritageClauses = !length(baseTypes) ? undefined : [createHeritageClause(SyntaxKind.ExtendsKeyword, map(baseTypes, b => serializeBaseType(b, staticBaseType, localName)))];
+                    const heritageClauses = [
+                        ...!length(baseTypes) ? [] : [createHeritageClause(SyntaxKind.ExtendsKeyword, map(baseTypes, b => serializeBaseType(b, staticBaseType, localName)))],
+                        ...!length(implementsTypes) ? [] : [createHeritageClause(SyntaxKind.ImplementsKeyword, map(implementsTypes, b => serializeBaseType(b, staticBaseType, localName)))]
+                    ];
                     const symbolProps = getPropertiesOfType(classType);
                     const publicSymbolProps = filter(symbolProps, s => {
                         const valueDecl = s.valueDeclaration;
@@ -8063,6 +8067,17 @@ namespace ts {
             return type.resolvedBaseConstructorType;
         }
 
+        function getImplementsTypes(type: InterfaceType): BaseType[] {
+            if (!type.resolvedImplementsTypes) {
+                if (type.symbol.flags & SymbolFlags.Class) {
+                    resolveImplementsTypesOfClass(type);
+                }
+                else {
+                    Debug.fail("type must be an interface");
+                }
+            }
+            return type.resolvedImplementsTypes;
+        }
         function getBaseTypes(type: InterfaceType): BaseType[] {
             if (!type.resolvedBaseTypes) {
                 if (type.objectFlags & ObjectFlags.Tuple) {
@@ -8162,6 +8177,29 @@ namespace ts {
                 !!(type.flags & TypeFlags.Intersection) && every((<IntersectionType>type).types, isValidBaseType);
         }
 
+        function resolveImplementsTypesOfClass(type: InterfaceType) {
+            type.resolvedImplementsTypes = type.resolvedImplementsTypes || emptyArray;
+            for (const declaration of type.symbol.declarations) {
+
+                if (!isClassLike(declaration)) continue;
+
+                const implementsTypeNodes = getEffectiveImplementsTypeNodes(declaration);
+
+                if (!implementsTypeNodes) continue;
+
+                for (const node of implementsTypeNodes) {
+                    const implementsType = getTypeFromTypeNode(node);
+                    if (implementsType !== errorType) {
+                        if (type.resolvedImplementsTypes === emptyArray) {
+                            type.resolvedImplementsTypes = [<ObjectType>implementsType];
+                        }
+                        else {
+                            type.resolvedImplementsTypes.push(implementsType);
+                        }
+                    }
+                }
+            }
+        }
         function resolveBaseTypesOfInterface(type: InterfaceType): void {
             type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
             for (const declaration of type.symbol.declarations) {

src/compiler/types.ts

@@ -4468,6 +4468,8 @@ namespace ts {
         resolvedBaseConstructorType?: Type;               // Resolved base constructor type of class
         /* @internal */
         resolvedBaseTypes: BaseType[];                    // Resolved base types
+        /* @internal */
+        resolvedImplementsTypes: BaseType[];              // Resolved implements types
     }
 
     // Object type or intersection of object types

src/compiler/utilities.ts

@@ -2775,7 +2775,7 @@ namespace ts {
         }
         else {
             const heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
-            return heritageClause ? heritageClause.types : undefined;
+            return heritageClause?.types;
         }
     }
 

tests/baselines/reference/jsdocImplements_class.errors.txt

@@ -10,7 +10,7 @@
         /** @return {number} */
         method() { throw new Error(); }
     }
-    /** @implements A */
+    /** @implements {A} */
     class B  {
         method() { return 0 }
     }
@@ -25,7 +25,7 @@
 !!! error TS2416:     Type 'string' is not assignable to type 'number'.
     }
 
-    /** @implements A */
+    /** @implements {A} */
     class B3  {
           ~~
 !!! error TS2720: Class 'B3' incorrectly implements class 'A'. Did you mean to extend 'A' and inherit its members as a subclass?

tests/baselines/reference/jsdocImplements_class.js

@@ -0,0 +1,40 @@
+//// [a.js]
+class A {
+    /** @return {number} */
+    method() { throw new Error(); }
+}
+/** @implements {A} */
+class B  {
+    method() { return 0 }
+}
+
+/** @implements A */
+class B2  {
+    /** @return {string} */
+    method() { return "" }
+}
+
+/** @implements {A} */
+class B3  {
+}
+
+
+
+
+//// [a.d.ts]
+declare class A {
+    /** @return {number} */
+    method(): number;
+}
+/** @implements {A} */
+declare class B implements A {
+    method(): number;
+}
+/** @implements A */
+declare class B2 implements A {
+    /** @return {string} */
+    method(): string;
+}
+/** @implements {A} */
+declare class B3 implements A {
+}

tests/baselines/reference/jsdocImplements_class.symbols

@@ -7,7 +7,7 @@ class A {
 >method : Symbol(A.method, Decl(a.js, 0, 9))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
-/** @implements A */
+/** @implements {A} */
 class B  {
 >B : Symbol(B, Decl(a.js, 3, 1))
 
@@ -24,7 +24,7 @@ class B2  {
 >method : Symbol(B2.method, Decl(a.js, 10, 11))
 }
 
-/** @implements A */
+/** @implements {A} */
 class B3  {
 >B3 : Symbol(B3, Decl(a.js, 13, 1))
 }

tests/baselines/reference/jsdocImplements_class.types

@@ -8,7 +8,7 @@ class A {
 >new Error() : Error
 >Error : ErrorConstructor
 }
-/** @implements A */
+/** @implements {A} */
 class B  {
 >B : B
 
@@ -27,7 +27,7 @@ class B2  {
 >"" : ""
 }
 
-/** @implements A */
+/** @implements {A} */
 class B3  {
 >B3 : B3
 }

tests/baselines/reference/jsdocImplements_interface.errors.txt

@@ -16,7 +16,7 @@
             return 0;
         }
     }
-    /** @implements A */
+    /** @implements {A} */
     class B2 {
         mNumber() {
         ~~~~~~~

tests/baselines/reference/jsdocImplements_interface.js

@@ -0,0 +1,38 @@
+//// [tests/cases/conformance/jsdoc/jsdocImplements_interface.ts] ////
+
+//// [defs.d.ts]
+interface A {
+    mNumber(): number;
+}
+//// [a.js]
+/** @implements A */
+class B {
+    mNumber() {
+        return 0;
+    }
+}
+/** @implements {A} */
+class B2 {
+    mNumber() {
+        return "";
+    }
+}
+/** @implements A */
+class B3 {
+}
+
+
+
+
+//// [a.d.ts]
+/** @implements A */
+declare class B implements A {
+    mNumber(): number;
+}
+/** @implements {A} */
+declare class B2 implements A {
+    mNumber(): string;
+}
+/** @implements A */
+declare class B3 implements A {
+}

tests/baselines/reference/jsdocImplements_interface.symbols

@@ -16,7 +16,7 @@ class B {
         return 0;
     }
 }
-/** @implements A */
+/** @implements {A} */
 class B2 {
 >B2 : Symbol(B2, Decl(a.js, 5, 1))
 

tests/baselines/reference/jsdocImplements_interface.types

@@ -15,7 +15,7 @@ class B {
 >0 : 0
     }
 }
-/** @implements A */
+/** @implements {A} */
 class B2 {
 >B2 : B2
 

tests/baselines/reference/jsdocImplements_interface_multiple.errors.txt

@@ -11,7 +11,7 @@
     }
 ==== /a.js (1 errors) ====
     /** 
-     * @implements Drawable 
+     * @implements {Drawable} 
      * @implements Sizable 
      **/
     class Square {
@@ -24,7 +24,7 @@
     }
     /**
      * @implements Drawable
-     * @implements Sizable
+     * @implements {Sizable}
      **/
     class BadSquare {
           ~~~~~~~~~

tests/baselines/reference/jsdocImplements_interface_multiple.js

@@ -0,0 +1,50 @@
+//// [tests/cases/conformance/jsdoc/jsdocImplements_interface_multiple.ts] ////
+
+//// [defs.d.ts]
+interface Drawable {
+    draw(): number;
+}
+interface Sizable {
+    size(): number;
+}
+//// [a.js]
+/** 
+ * @implements {Drawable} 
+ * @implements Sizable 
+ **/
+class Square {
+    draw() {
+        return 0;
+    }
+    size() {
+        return 0;
+    }
+}
+/**
+ * @implements Drawable
+ * @implements {Sizable}
+ **/
+class BadSquare {
+    size() {
+        return 0;
+    }
+}
+
+
+
+//// [a.d.ts]
+/**
+ * @implements {Drawable}
+ * @implements Sizable
+ **/
+declare class Square implements Drawable, Sizable {
+    draw(): number;
+    size(): number;
+}
+/**
+ * @implements Drawable
+ * @implements {Sizable}
+ **/
+declare class BadSquare implements Drawable, Sizable {
+    size(): number;
+}

tests/baselines/reference/jsdocImplements_interface_multiple.symbols

@@ -13,7 +13,7 @@ interface Sizable {
 }
 === /a.js ===
 /** 
- * @implements Drawable 
+ * @implements {Drawable} 
  * @implements Sizable 
  **/
 class Square {
@@ -32,7 +32,7 @@ class Square {
 }
 /**
  * @implements Drawable
- * @implements Sizable
+ * @implements {Sizable}
  **/
 class BadSquare {
 >BadSquare : Symbol(BadSquare, Decl(a.js, 11, 1))

tests/baselines/reference/jsdocImplements_interface_multiple.types

@@ -9,7 +9,7 @@ interface Sizable {
 }
 === /a.js ===
 /** 
- * @implements Drawable 
+ * @implements {Drawable} 
  * @implements Sizable 
  **/
 class Square {
@@ -30,7 +30,7 @@ class Square {
 }
 /**
  * @implements Drawable
- * @implements Sizable
+ * @implements {Sizable}
  **/
 class BadSquare {
 >BadSquare : BadSquare

tests/baselines/reference/jsdocImplements_missingType.js

@@ -0,0 +1,16 @@
+//// [a.js]
+class A { constructor() { this.x = 0; } }
+/** @implements */
+class B  {
+}
+
+
+
+
+//// [a.d.ts]
+declare class A {
+    x: number;
+}
+/** @implements */
+declare class B {
+}

tests/baselines/reference/jsdocImplements_properties.errors.txt

@@ -16,7 +16,7 @@
         x = 10
     }
 
-    /** @implements A*/
+    /** @implements {A}*/
     class B3 {
         constructor() { this.x = 10 }
     }