Improve mergedInheritedClassInterface test case

Covers the case when the merged interface extends an interface, but the
merged class does not extend a class, then trying to extend that class.

tests/baselines/reference/mergedInheritedClassInterface.js

@@ -4,8 +4,8 @@ interface BaseInterface {
     optional?: number;
 }
 
-declare class BaseClass {
-    baseMethod();
+class BaseClass {
+    baseMethod() { }
     baseNumber: number;
 }
 
@@ -13,9 +13,19 @@ interface Child extends BaseInterface {
     additional: number;
 }
 
-declare class Child extends BaseClass {
+class Child extends BaseClass {
     classNumber: number;
-    method();
+    method() { }
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+    additional2: string;
+}
+class ChildNoBaseClass {
+    classString: string;
+    method2() { }
+}
+class Grandchild extends ChildNoBaseClass {
 }
 
 // checks if properties actually were merged
@@ -27,9 +37,48 @@ child.baseNumber;
 child.classNumber;
 child.baseMethod();
 child.method();
+
+var grandchild: Grandchild;
+grandchild.required;
+grandchild.optional;
+grandchild.additional2;
+grandchild.classString;
+grandchild.method2();
 
 
 //// [mergedInheritedClassInterface.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var BaseClass = (function () {
+    function BaseClass() {
+    }
+    BaseClass.prototype.baseMethod = function () { };
+    return BaseClass;
+})();
+var Child = (function (_super) {
+    __extends(Child, _super);
+    function Child() {
+        _super.apply(this, arguments);
+    }
+    Child.prototype.method = function () { };
+    return Child;
+})(BaseClass);
+var ChildNoBaseClass = (function () {
+    function ChildNoBaseClass() {
+    }
+    ChildNoBaseClass.prototype.method2 = function () { };
+    return ChildNoBaseClass;
+})();
+var Grandchild = (function (_super) {
+    __extends(Grandchild, _super);
+    function Grandchild() {
+        _super.apply(this, arguments);
+    }
+    return Grandchild;
+})(ChildNoBaseClass);
 // checks if properties actually were merged
 var child;
 child.required;
@@ -39,3 +88,9 @@ child.baseNumber;
 child.classNumber;
 child.baseMethod();
 child.method();
+var grandchild;
+grandchild.required;
+grandchild.optional;
+grandchild.additional2;
+grandchild.classString;
+grandchild.method2();

tests/baselines/reference/mergedInheritedClassInterface.symbols

@@ -9,14 +9,14 @@ interface BaseInterface {
 >optional : Symbol(optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
 }
 
-declare class BaseClass {
+class BaseClass {
 >BaseClass : Symbol(BaseClass, Decl(mergedInheritedClassInterface.ts, 3, 1))
 
-    baseMethod();
->baseMethod : Symbol(baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 25))
+    baseMethod() { }
+>baseMethod : Symbol(baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 17))
 
     baseNumber: number;
->baseNumber : Symbol(baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 17))
+>baseNumber : Symbol(baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 20))
 }
 
 interface Child extends BaseInterface {
@@ -27,54 +27,104 @@ interface Child extends BaseInterface {
 >additional : Symbol(additional, Decl(mergedInheritedClassInterface.ts, 10, 39))
 }
 
-declare class Child extends BaseClass {
+class Child extends BaseClass {
 >Child : Symbol(Child, Decl(mergedInheritedClassInterface.ts, 8, 1), Decl(mergedInheritedClassInterface.ts, 12, 1))
 >BaseClass : Symbol(BaseClass, Decl(mergedInheritedClassInterface.ts, 3, 1))
 
     classNumber: number;
->classNumber : Symbol(classNumber, Decl(mergedInheritedClassInterface.ts, 14, 39))
+>classNumber : Symbol(classNumber, Decl(mergedInheritedClassInterface.ts, 14, 31))
 
-    method();
+    method() { }
 >method : Symbol(method, Decl(mergedInheritedClassInterface.ts, 15, 24))
 }
 
+interface ChildNoBaseClass extends BaseInterface {
+>ChildNoBaseClass : Symbol(ChildNoBaseClass, Decl(mergedInheritedClassInterface.ts, 17, 1), Decl(mergedInheritedClassInterface.ts, 21, 1))
+>BaseInterface : Symbol(BaseInterface, Decl(mergedInheritedClassInterface.ts, 0, 0))
+
+    additional2: string;
+>additional2 : Symbol(additional2, Decl(mergedInheritedClassInterface.ts, 19, 50))
+}
+class ChildNoBaseClass {
+>ChildNoBaseClass : Symbol(ChildNoBaseClass, Decl(mergedInheritedClassInterface.ts, 17, 1), Decl(mergedInheritedClassInterface.ts, 21, 1))
+
+    classString: string;
+>classString : Symbol(classString, Decl(mergedInheritedClassInterface.ts, 22, 24))
+
+    method2() { }
+>method2 : Symbol(method2, Decl(mergedInheritedClassInterface.ts, 23, 24))
+}
+class Grandchild extends ChildNoBaseClass {
+>Grandchild : Symbol(Grandchild, Decl(mergedInheritedClassInterface.ts, 25, 1))
+>ChildNoBaseClass : Symbol(ChildNoBaseClass, Decl(mergedInheritedClassInterface.ts, 17, 1), Decl(mergedInheritedClassInterface.ts, 21, 1))
+}
+
 // checks if properties actually were merged
 var child : Child;
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
 >Child : Symbol(Child, Decl(mergedInheritedClassInterface.ts, 8, 1), Decl(mergedInheritedClassInterface.ts, 12, 1))
 
 child.required;
 >child.required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
 >required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
 
 child.optional;
 >child.optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
 >optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
 
 child.additional;
 >child.additional : Symbol(Child.additional, Decl(mergedInheritedClassInterface.ts, 10, 39))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
 >additional : Symbol(Child.additional, Decl(mergedInheritedClassInterface.ts, 10, 39))
 
 child.baseNumber;
->child.baseNumber : Symbol(BaseClass.baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 17))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
->baseNumber : Symbol(BaseClass.baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 17))
+>child.baseNumber : Symbol(BaseClass.baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 20))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>baseNumber : Symbol(BaseClass.baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 20))
 
 child.classNumber;
->child.classNumber : Symbol(Child.classNumber, Decl(mergedInheritedClassInterface.ts, 14, 39))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
->classNumber : Symbol(Child.classNumber, Decl(mergedInheritedClassInterface.ts, 14, 39))
+>child.classNumber : Symbol(Child.classNumber, Decl(mergedInheritedClassInterface.ts, 14, 31))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>classNumber : Symbol(Child.classNumber, Decl(mergedInheritedClassInterface.ts, 14, 31))
 
 child.baseMethod();
->child.baseMethod : Symbol(BaseClass.baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 25))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
->baseMethod : Symbol(BaseClass.baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 25))
+>child.baseMethod : Symbol(BaseClass.baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 17))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>baseMethod : Symbol(BaseClass.baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 17))
 
 child.method();
 >child.method : Symbol(Child.method, Decl(mergedInheritedClassInterface.ts, 15, 24))
->child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 20, 3))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
 >method : Symbol(Child.method, Decl(mergedInheritedClassInterface.ts, 15, 24))
 
+var grandchild: Grandchild;
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>Grandchild : Symbol(Grandchild, Decl(mergedInheritedClassInterface.ts, 25, 1))
+
+grandchild.required;
+>grandchild.required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+
+grandchild.optional;
+>grandchild.optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+
+grandchild.additional2;
+>grandchild.additional2 : Symbol(ChildNoBaseClass.additional2, Decl(mergedInheritedClassInterface.ts, 19, 50))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>additional2 : Symbol(ChildNoBaseClass.additional2, Decl(mergedInheritedClassInterface.ts, 19, 50))
+
+grandchild.classString;
+>grandchild.classString : Symbol(ChildNoBaseClass.classString, Decl(mergedInheritedClassInterface.ts, 22, 24))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>classString : Symbol(ChildNoBaseClass.classString, Decl(mergedInheritedClassInterface.ts, 22, 24))
+
+grandchild.method2();
+>grandchild.method2 : Symbol(ChildNoBaseClass.method2, Decl(mergedInheritedClassInterface.ts, 23, 24))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>method2 : Symbol(ChildNoBaseClass.method2, Decl(mergedInheritedClassInterface.ts, 23, 24))
+

tests/baselines/reference/mergedInheritedClassInterface.types

@@ -9,11 +9,11 @@ interface BaseInterface {
 >optional : number
 }
 
-declare class BaseClass {
+class BaseClass {
 >BaseClass : BaseClass
 
-    baseMethod();
->baseMethod : () => any
+    baseMethod() { }
+>baseMethod : () => void
 
     baseNumber: number;
 >baseNumber : number
@@ -27,15 +27,36 @@ interface Child extends BaseInterface {
 >additional : number
 }
 
-declare class Child extends BaseClass {
+class Child extends BaseClass {
 >Child : Child
 >BaseClass : BaseClass
 
     classNumber: number;
 >classNumber : number
 
-    method();
->method : () => any
+    method() { }
+>method : () => void
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+>ChildNoBaseClass : ChildNoBaseClass
+>BaseInterface : BaseInterface
+
+    additional2: string;
+>additional2 : string
+}
+class ChildNoBaseClass {
+>ChildNoBaseClass : ChildNoBaseClass
+
+    classString: string;
+>classString : string
+
+    method2() { }
+>method2 : () => void
+}
+class Grandchild extends ChildNoBaseClass {
+>Grandchild : Grandchild
+>ChildNoBaseClass : ChildNoBaseClass
 }
 
 // checks if properties actually were merged
@@ -69,14 +90,44 @@ child.classNumber;
 >classNumber : number
 
 child.baseMethod();
->child.baseMethod() : any
->child.baseMethod : () => any
+>child.baseMethod() : void
+>child.baseMethod : () => void
 >child : Child
->baseMethod : () => any
+>baseMethod : () => void
 
 child.method();
->child.method() : any
->child.method : () => any
+>child.method() : void
+>child.method : () => void
 >child : Child
->method : () => any
+>method : () => void
+
+var grandchild: Grandchild;
+>grandchild : Grandchild
+>Grandchild : Grandchild
+
+grandchild.required;
+>grandchild.required : number
+>grandchild : Grandchild
+>required : number
+
+grandchild.optional;
+>grandchild.optional : number
+>grandchild : Grandchild
+>optional : number
+
+grandchild.additional2;
+>grandchild.additional2 : string
+>grandchild : Grandchild
+>additional2 : string
+
+grandchild.classString;
+>grandchild.classString : string
+>grandchild : Grandchild
+>classString : string
+
+grandchild.method2();
+>grandchild.method2() : void
+>grandchild.method2 : () => void
+>grandchild : Grandchild
+>method2 : () => void
 

tests/cases/conformance/classes/classDeclarations/mergedInheritedClassInterface.ts

@@ -3,8 +3,8 @@ interface BaseInterface {
     optional?: number;
 }
 
-declare class BaseClass {
-    baseMethod();
+class BaseClass {
+    baseMethod() { }
     baseNumber: number;
 }
 
@@ -12,9 +12,19 @@ interface Child extends BaseInterface {
     additional: number;
 }
 
-declare class Child extends BaseClass {
+class Child extends BaseClass {
     classNumber: number;
-    method();
+    method() { }
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+    additional2: string;
+}
+class ChildNoBaseClass {
+    classString: string;
+    method2() { }
+}
+class Grandchild extends ChildNoBaseClass {
 }
 
 // checks if properties actually were merged
@@ -26,3 +36,10 @@ child.baseNumber;
 child.classNumber;
 child.baseMethod();
 child.method();
+
+var grandchild: Grandchild;
+grandchild.required;
+grandchild.optional;
+grandchild.additional2;
+grandchild.classString;
+grandchild.method2();