Add tests for extension, type arguments, overload

Author: Yui T

src/compiler/emitter.ts

@@ -4407,7 +4407,9 @@ module ts {
                     emitComputedPropertyName(<ComputedPropertyName>memberName);
                 }
                 else {
-                    if (languageVersion < ScriptTarget.ES6) {
+                    // For script-target that is ES6 or above, we want to emit memberName by itself without prefix "." if the memberName is a name of method.
+                    // If the memberName is the name of property, we need to emit it with prefix ".".
+                    if (languageVersion < ScriptTarget.ES6 || memberName.parent.kind === SyntaxKind.PropertyDeclaration) {
                         write(".");
                     }
                     emitNodeWithoutSourceMap(memberName);
@@ -4667,7 +4669,7 @@ module ts {
                 var baseTypeNode = getClassBaseTypeNode(node);
                 if (baseTypeNode) {
                     write(" extends ");
-                    emitDeclarationName(node);
+                    emitNodeWithoutSourceMap(baseTypeNode.typeName);
                 }
                 write(" {");
                 increaseIndent();

tests/baselines/reference/emitClassDeclarationWithConstructorInES6.js

@@ -0,0 +1,26 @@
+//// [emitClassDeclarationWithConstructorInES6.ts]
+class C {
+    y: number;
+    constructor(x: number) {
+    }
+}
+
+class D {
+    y: number;
+    x: string = "hello";
+    constructor(x: number, z = "hello") {
+        this.y = 10;
+    }
+}
+
+//// [emitClassDeclarationWithConstructorInES6.js]
+class C {
+    constructor(x) {
+    }
+}
+class D {
+    constructor(x, z = "hello") {
+        this.x = "hello";
+        this.y = 10;
+    }
+}

tests/baselines/reference/emitClassDeclarationWithConstructorInES6.types

@@ -0,0 +1,32 @@
+=== tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithConstructorInES6.ts ===
+class C {
+>C : C
+
+    y: number;
+>y : number
+
+    constructor(x: number) {
+>x : number
+    }
+}
+
+class D {
+>D : D
+
+    y: number;
+>y : number
+
+    x: string = "hello";
+>x : string
+
+    constructor(x: number, z = "hello") {
+>x : number
+>z : string
+
+        this.y = 10;
+>this.y = 10 : number
+>this.y : number
+>this : D
+>y : number
+    }
+}

tests/baselines/reference/emitClassDeclarationWithConstructorPropertyAssignmentInES6.js

@@ -27,25 +27,25 @@ class F extends D{
 //// [emitClassDeclarationWithConstructorPropertyAssignmentInES6.js]
 class C {
     constructor() {
-        thisx = "Hello world";
+        this.x = "Hello world";
     }
 }
 class D {
     constructor() {
-        thisx = "Hello world";
+        this.x = "Hello world";
         this.y = 10;
     }
 }
-class E extends E {
+class E extends D {
     constructor(...args) {
         super(...args);
-        thisz = true;
+        this.z = true;
     }
 }
-class F extends F {
+class F extends D {
     constructor() {
         super();
-        thisz = true;
+        this.z = true;
         this.j = "HI";
     }
 }

tests/baselines/reference/emitClassDeclarationWithExtensionAndTypeArgumentInES6.js

@@ -0,0 +1,27 @@
+//// [emitClassDeclarationWithExtensionAndTypeArgumentInES6.ts]
+class B<T> {
+    constructor(a: T) { }
+}
+class C extends B<string> { }
+class D extends B<number> {
+    constructor(a: any)
+    constructor(b: number) {
+        super(b);
+    }
+}
+
+//// [emitClassDeclarationWithExtensionAndTypeArgumentInES6.js]
+class B {
+    constructor(a) {
+    }
+}
+class C extends B {
+    constructor(...args) {
+        super(...args);
+    }
+}
+class D extends B {
+    constructor(b) {
+        super(b);
+    }
+}

tests/baselines/reference/emitClassDeclarationWithExtensionAndTypeArgumentInES6.types

@@ -0,0 +1,29 @@
+=== tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithExtensionAndTypeArgumentInES6.ts ===
+class B<T> {
+>B : B<T>
+>T : T
+
+    constructor(a: T) { }
+>a : T
+>T : T
+}
+class C extends B<string> { }
+>C : C
+>B : B<T>
+
+class D extends B<number> {
+>D : D
+>B : B<T>
+
+    constructor(a: any)
+>a : any
+
+    constructor(b: number) {
+>b : number
+
+        super(b);
+>super(b) : void
+>super : typeof B
+>b : number
+    }
+}

tests/baselines/reference/emitClassDeclarationWithExtensionInES6.js

@@ -0,0 +1,25 @@
+//// [emitClassDeclarationWithExtensionInES6.ts]
+class B { }
+class C extends B { }
+class D extends B {
+    constructor() {
+        super();
+    }
+}
+
+
+//// [emitClassDeclarationWithExtensionInES6.js]
+class B {
+    constructor() {
+    }
+}
+class C extends B {
+    constructor(...args) {
+        super(...args);
+    }
+}
+class D extends B {
+    constructor() {
+        super();
+    }
+}

tests/baselines/reference/emitClassDeclarationWithExtensionInES6.types

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithExtensionInES6.ts ===
+class B { }
+>B : B
+
+class C extends B { }
+>C : C
+>B : B
+
+class D extends B {
+>D : D
+>B : B
+
+    constructor() {
+        super();
+>super() : void
+>super : typeof B
+    }
+}
+

tests/baselines/reference/emitClassDeclarationWithMethodInES6.js

@@ -1,15 +1,25 @@
 //// [emitClassDeclarationWithMethodInES6.ts]
 class D {
+    _bar: string;
     foo() { }
     ["computedName"]() { }
     ["computedName"](a: string) { }
     ["computedName"](a: string): number { return 1; }
     bar(): string {
-        return "HI";
+        return this._bar;
     } 
     baz(a: any, x: string): string {
         return "HELLO";
     }
+    static ["computedname"]() { }
+    static ["computedname"](a: string) { }
+    static ["computedname"](a: string): boolean { return true; }
+    static staticMethod() {
+        var x = 1 + 2;
+        return x
+    }
+    static foo(a: string) { }
+    static bar(a: string): number { return 1; }
 }
 
 //// [emitClassDeclarationWithMethodInES6.js]
@@ -26,9 +36,25 @@ class D {
         return 1;
     }
     bar() {
-        return "HI";
+        return this._bar;
     }
     baz(a, x) {
         return "HELLO";
     }
+    static ["computedname"]() {
+    }
+    static ["computedname"](a) {
+    }
+    static ["computedname"](a) {
+        return true;
+    }
+    static staticMethod() {
+        var x = 1 + 2;
+        return x;
+    }
+    static foo(a) {
+    }
+    static bar(a) {
+        return 1;
+    }
 }

tests/baselines/reference/emitClassDeclarationWithMethodInES6.types

@@ -2,6 +2,9 @@
 class D {
 >D : D
 
+    _bar: string;
+>_bar : string
+
     foo() { }
 >foo : () => void
 
@@ -15,7 +18,10 @@ class D {
     bar(): string {
 >bar : () => string
 
-        return "HI";
+        return this._bar;
+>this._bar : string
+>this : D
+>_bar : string
     } 
     baz(a: any, x: string): string {
 >baz : (a: any, x: string) => string
@@ -24,4 +30,28 @@ class D {
 
         return "HELLO";
     }
+    static ["computedname"]() { }
+    static ["computedname"](a: string) { }
+>a : string
+
+    static ["computedname"](a: string): boolean { return true; }
+>a : string
+
+    static staticMethod() {
+>staticMethod : () => number
+
+        var x = 1 + 2;
+>x : number
+>1 + 2 : number
+
+        return x
+>x : number
+    }
+    static foo(a: string) { }
+>foo : (a: string) => void
+>a : string
+
+    static bar(a: string): number { return 1; }
+>bar : (a: string) => number
+>a : string
 }