Use variable name for class and function expressions names

mhegazy · mhegazy · commit e8a2173feed5 · 2017-01-23T23:03:11.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -2171,13 +2171,15 @@ namespace ts {
             return type.flags & TypeFlags.StringLiteral ? `"${escapeString((<LiteralType>type).text)}"` : (<LiteralType>type).text;
         }
 
-
         function getNameOfSymbol(symbol: Symbol): string {
             if (symbol.declarations && symbol.declarations.length) {
                 const declaration = symbol.declarations[0];
                 if (declaration.name) {
                     return declarationNameToString(declaration.name);
                 }
+                if (declaration.parent && declaration.parent.kind === SyntaxKind.VariableDeclaration) {
+                    return declarationNameToString((<VariableDeclaration>declaration.parent).name);
+                }
                 switch (declaration.kind) {
                     case SyntaxKind.ClassExpression:
                         return "(Anonymous class)";
diff --git a/tests/baselines/reference/classExpression3.symbols b/tests/baselines/reference/classExpression3.symbols
@@ -3,7 +3,7 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpression3.ts, 0, 3))
 >a : Symbol((Anonymous class).a, Decl(classExpression3.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53))
->c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63))
+>c : Symbol(C.c, Decl(classExpression3.ts, 0, 63))
 
 let c = new C();
 >c : Symbol(c, Decl(classExpression3.ts, 1, 3))
@@ -20,7 +20,7 @@ c.b;
 >b : Symbol((Anonymous class).b, Decl(classExpression3.ts, 0, 53))
 
 c.c;
->c.c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63))
+>c.c : Symbol(C.c, Decl(classExpression3.ts, 0, 63))
 >c : Symbol(c, Decl(classExpression3.ts, 1, 3))
->c : Symbol((Anonymous class).c, Decl(classExpression3.ts, 0, 63))
+>c : Symbol(C.c, Decl(classExpression3.ts, 0, 63))
 
diff --git a/tests/baselines/reference/classExpression3.types b/tests/baselines/reference/classExpression3.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/classes/classExpressions/classExpression3.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
->C : typeof (Anonymous class)
->class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof (Anonymous class)
+>C : typeof C
+>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof C
 >class extends class { a = 1 } { b = 2 } : (Anonymous class)
 >class { a = 1 } : (Anonymous class)
 >a : number
@@ -12,22 +12,22 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >3 : 3
 
 let c = new C();
->c : (Anonymous class)
->new C() : (Anonymous class)
->C : typeof (Anonymous class)
+>c : C
+>new C() : C
+>C : typeof C
 
 c.a;
 >c.a : number
->c : (Anonymous class)
+>c : C
 >a : number
 
 c.b;
 >c.b : number
->c : (Anonymous class)
+>c : C
 >b : number
 
 c.c;
 >c.c : number
->c : (Anonymous class)
+>c : C
 >c : number
 
diff --git a/tests/baselines/reference/classExpression4.symbols b/tests/baselines/reference/classExpression4.symbols
@@ -3,15 +3,15 @@ let C = class {
 >C : Symbol(C, Decl(classExpression4.ts, 0, 3))
 
     foo() {
->foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15))
+>foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15))
 
         return new C();
 >C : Symbol(C, Decl(classExpression4.ts, 0, 3))
     }
 };
 let x = (new C).foo();
 >x : Symbol(x, Decl(classExpression4.ts, 5, 3))
->(new C).foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15))
+>(new C).foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15))
 >C : Symbol(C, Decl(classExpression4.ts, 0, 3))
->foo : Symbol((Anonymous class).foo, Decl(classExpression4.ts, 0, 15))
+>foo : Symbol(C.foo, Decl(classExpression4.ts, 0, 15))
 
diff --git a/tests/baselines/reference/classExpression4.types b/tests/baselines/reference/classExpression4.types
@@ -1,22 +1,22 @@
 === tests/cases/conformance/classes/classExpressions/classExpression4.ts ===
 let C = class {
->C : typeof (Anonymous class)
->class {    foo() {        return new C();    }} : typeof (Anonymous class)
+>C : typeof C
+>class {    foo() {        return new C();    }} : typeof C
 
     foo() {
->foo : () => (Anonymous class)
+>foo : () => C
 
         return new C();
->new C() : (Anonymous class)
->C : typeof (Anonymous class)
+>new C() : C
+>C : typeof C
     }
 };
 let x = (new C).foo();
->x : (Anonymous class)
->(new C).foo() : (Anonymous class)
->(new C).foo : () => (Anonymous class)
->(new C) : (Anonymous class)
->new C : (Anonymous class)
->C : typeof (Anonymous class)
->foo : () => (Anonymous class)
+>x : C
+>(new C).foo() : C
+>(new C).foo : () => C
+>(new C) : C
+>new C : C
+>C : typeof C
+>foo : () => C
 
diff --git a/tests/baselines/reference/classExpressionES63.symbols b/tests/baselines/reference/classExpressionES63.symbols
@@ -3,7 +3,7 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >C : Symbol(C, Decl(classExpressionES63.ts, 0, 3))
 >a : Symbol((Anonymous class).a, Decl(classExpressionES63.ts, 0, 43))
 >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53))
->c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63))
+>c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63))
 
 let c = new C();
 >c : Symbol(c, Decl(classExpressionES63.ts, 1, 3))
@@ -20,7 +20,7 @@ c.b;
 >b : Symbol((Anonymous class).b, Decl(classExpressionES63.ts, 0, 53))
 
 c.c;
->c.c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63))
+>c.c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63))
 >c : Symbol(c, Decl(classExpressionES63.ts, 1, 3))
->c : Symbol((Anonymous class).c, Decl(classExpressionES63.ts, 0, 63))
+>c : Symbol(C.c, Decl(classExpressionES63.ts, 0, 63))
 
diff --git a/tests/baselines/reference/classExpressionES63.types b/tests/baselines/reference/classExpressionES63.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/classExpressions/classExpressionES63.ts ===
 let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
->C : typeof (Anonymous class)
->class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof (Anonymous class)
+>C : typeof C
+>class extends class extends class { a = 1 } { b = 2 } { c = 3 } : typeof C
 >class extends class { a = 1 } { b = 2 } : (Anonymous class)
 >class { a = 1 } : (Anonymous class)
 >a : number
@@ -12,22 +12,22 @@ let C = class extends class extends class { a = 1 } { b = 2 } { c = 3 };
 >3 : 3
 
 let c = new C();
->c : (Anonymous class)
->new C() : (Anonymous class)
->C : typeof (Anonymous class)
+>c : C
+>new C() : C
+>C : typeof C
 
 c.a;
 >c.a : number
->c : (Anonymous class)
+>c : C
 >a : number
 
 c.b;
 >c.b : number
->c : (Anonymous class)
+>c : C
 >b : number
 
 c.c;
 >c.c : number
->c : (Anonymous class)
+>c : C
 >c : number
 
diff --git a/tests/baselines/reference/functionsInClassExpressions.symbols b/tests/baselines/reference/functionsInClassExpressions.symbols
@@ -4,24 +4,24 @@ let Foo = class {
 
     constructor() {
         this.bar++;
->this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
->this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this.bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9))
+>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
     }
     bar = 0;
->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
 
     inc = () => {
->inc : Symbol((Anonymous class).inc, Decl(functionsInClassExpressions.ts, 4, 12))
+>inc : Symbol(Foo.inc, Decl(functionsInClassExpressions.ts, 4, 12))
 
         this.bar++;
->this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
->this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this.bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9))
+>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
     }
     m() { return this.bar; }
->m : Symbol((Anonymous class).m, Decl(functionsInClassExpressions.ts, 7, 5))
->this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
->this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
->bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>m : Symbol(Foo.m, Decl(functionsInClassExpressions.ts, 7, 5))
+>this.bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 9))
+>bar : Symbol(Foo.bar, Decl(functionsInClassExpressions.ts, 3, 5))
 }
diff --git a/tests/baselines/reference/functionsInClassExpressions.types b/tests/baselines/reference/functionsInClassExpressions.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/functionsInClassExpressions.ts ===
 let Foo = class {
->Foo : typeof (Anonymous class)
->class {    constructor() {        this.bar++;    }    bar = 0;    inc = () => {        this.bar++;    }    m() { return this.bar; }} : typeof (Anonymous class)
+>Foo : typeof Foo
+>class {    constructor() {        this.bar++;    }    bar = 0;    inc = () => {        this.bar++;    }    m() { return this.bar; }} : typeof Foo
 
     constructor() {
         this.bar++;
diff --git a/tests/baselines/reference/implementsInClassExpression.symbols b/tests/baselines/reference/implementsInClassExpression.symbols
@@ -11,5 +11,5 @@ let cls = class implements Foo {
 >Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0))
 
     doThing() { }
->doThing : Symbol((Anonymous class).doThing, Decl(implementsInClassExpression.ts, 4, 32))
+>doThing : Symbol(cls.doThing, Decl(implementsInClassExpression.ts, 4, 32))
 }
diff --git a/tests/baselines/reference/implementsInClassExpression.types b/tests/baselines/reference/implementsInClassExpression.types
@@ -7,8 +7,8 @@ interface Foo {
 }
 
 let cls = class implements Foo {
->cls : typeof (Anonymous class)
->class implements Foo {    doThing() { }} : typeof (Anonymous class)
+>cls : typeof cls
+>class implements Foo {    doThing() { }} : typeof cls
 >Foo : Foo
 
     doThing() { }
diff --git a/tests/baselines/reference/staticPropertyNameConflicts.errors.txt b/tests/baselines/reference/staticPropertyNameConflicts.errors.txt
diff --git a/tests/baselines/reference/transformsElideNullUndefinedType.types b/tests/baselines/reference/transformsElideNullUndefinedType.types

Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,5 @@ let cls = class implements Foo {`
`11`	`11`	`>Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0))`
`12`	`12`
`13`	`13`	`doThing() { }`
`14`		`->doThing : Symbol((Anonymous class).doThing, Decl(implementsInClassExpression.ts, 4, 32))`
	`14`	`+>doThing : Symbol(cls.doThing, Decl(implementsInClassExpression.ts, 4, 32))`
`15`	`15`	`}`