diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types
index 0dfc19dea0665..34c399156fd78 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.types
@@ -32,8 +32,8 @@ var a: { new(x: Date): string }
 >x : Date
 
 var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new
->b : { new(x: RegExp): string; }
->{ new(x: RegExp) { return ''; } } : { new(x: RegExp): string; }
+>b : { "new"(x: RegExp): string; }
+>{ new(x: RegExp) { return ''; } } : { "new"(x: RegExp): string; }
 >new : (x: RegExp) => string
 >x : RegExp
 >'' : ""
@@ -89,17 +89,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new(x: RegExp): string; }): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>foo4 : { (x: typeof b): any; (x: { "new"(x: RegExp): string; }): any; }
+>x : { "new"(x: RegExp): string; }
+>b : { "new"(x: RegExp): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new(x: RegExp): string; }): any; (x: typeof b): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>foo4 : { (x: { "new"(x: RegExp): string; }): any; (x: typeof b): any; }
+>x : { "new"(x: RegExp): string; }
+>b : { "new"(x: RegExp): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new(x: RegExp): string; }): any; (x: { new(x: RegExp): string; }): any; }
+>foo4 : { (x: { "new"(x: RegExp): string; }): any; (x: { "new"(x: RegExp): string; }): any; }
 >x : any
 
 function foo8(x: B);
@@ -140,16 +140,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B);
->foo11 : { (x: B): any; (x: { new(x: RegExp): string; }): any; }
+>foo11 : { (x: B): any; (x: { "new"(x: RegExp): string; }): any; }
 >x : B
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B): any; (x: typeof b): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>x : { "new"(x: RegExp): string; }
+>b : { "new"(x: RegExp): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B): any; (x: { new(x: RegExp): string; }): any; }
+>foo11 : { (x: B): any; (x: { "new"(x: RegExp): string; }): any; }
 >x : any
 
 function foo12(x: I);
@@ -190,16 +190,16 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I);
->foo14 : { (x: I): any; (x: { new(x: RegExp): string; }): any; }
+>foo14 : { (x: I): any; (x: { "new"(x: RegExp): string; }): any; }
 >x : I
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I): any; (x: typeof b): any; }
->x : { new(x: RegExp): string; }
->b : { new(x: RegExp): string; }
+>x : { "new"(x: RegExp): string; }
+>b : { "new"(x: RegExp): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I): any; (x: { new(x: RegExp): string; }): any; }
+>foo14 : { (x: I): any; (x: { "new"(x: RegExp): string; }): any; }
 >x : any
 
 function foo15(x: I2<string>);
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.types b/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.types
index d77dd7fb06a90..bd1c494205e8c 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.types
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignaturesDifferingParamCounts.types
@@ -35,8 +35,8 @@ var a: { new(x: string, y: string): string }
 >y : string
 
 var b = { new(x: string) { return ''; } }; // not a construct signature, function called new
->b : { new(x: string): string; }
->{ new(x: string) { return ''; } } : { new(x: string): string; }
+>b : { "new"(x: string): string; }
+>{ new(x: string) { return ''; } } : { "new"(x: string): string; }
 >new : (x: string) => string
 >x : string
 >'' : ""
@@ -92,17 +92,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new(x: string): string; }): any; }
->x : { new(x: string): string; }
->b : { new(x: string): string; }
+>foo4 : { (x: typeof b): any; (x: { "new"(x: string): string; }): any; }
+>x : { "new"(x: string): string; }
+>b : { "new"(x: string): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new(x: string): string; }): any; (x: typeof b): any; }
->x : { new(x: string): string; }
->b : { new(x: string): string; }
+>foo4 : { (x: { "new"(x: string): string; }): any; (x: typeof b): any; }
+>x : { "new"(x: string): string; }
+>b : { "new"(x: string): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new(x: string): string; }): any; (x: { new(x: string): string; }): any; }
+>foo4 : { (x: { "new"(x: string): string; }): any; (x: { "new"(x: string): string; }): any; }
 >x : any
 
 function foo8(x: B);
@@ -143,16 +143,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B);
->foo11 : { (x: B): any; (x: { new(x: string): string; }): any; }
+>foo11 : { (x: B): any; (x: { "new"(x: string): string; }): any; }
 >x : B
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B): any; (x: typeof b): any; }
->x : { new(x: string): string; }
->b : { new(x: string): string; }
+>x : { "new"(x: string): string; }
+>b : { "new"(x: string): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B): any; (x: { new(x: string): string; }): any; }
+>foo11 : { (x: B): any; (x: { "new"(x: string): string; }): any; }
 >x : any
 
 function foo12(x: I);
@@ -193,16 +193,16 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I);
->foo14 : { (x: I): any; (x: { new(x: string): string; }): any; }
+>foo14 : { (x: I): any; (x: { "new"(x: string): string; }): any; }
 >x : I
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I): any; (x: typeof b): any; }
->x : { new(x: string): string; }
->b : { new(x: string): string; }
+>x : { "new"(x: string): string; }
+>b : { "new"(x: string): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I): any; (x: { new(x: string): string; }): any; }
+>foo14 : { (x: I): any; (x: { "new"(x: string): string; }): any; }
 >x : any
 
 function foo15(x: I2<string>);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types
index 0f0ef8d5d02ee..de2e1e509a695 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.types
@@ -34,8 +34,8 @@ var a: { new<T extends Array<string>>(x: T): string }
 >x : T
 
 var b = { new<T extends RegExp>(x: T) { return ''; } }; // not a construct signature, function called new
->b : { new<T extends RegExp>(x: T): string; }
->{ new<T extends RegExp>(x: T) { return ''; } } : { new<T extends RegExp>(x: T): string; }
+>b : { "new"<T extends RegExp>(x: T): string; }
+>{ new<T extends RegExp>(x: T) { return ''; } } : { "new"<T extends RegExp>(x: T): string; }
 >new : <T extends RegExp>(x: T) => string
 >x : T
 >'' : ""
@@ -91,17 +91,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T extends RegExp>(x: T): string; }): any; }
+>x : { "new"<T extends RegExp>(x: T): string; }
+>b : { "new"<T extends RegExp>(x: T): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T extends RegExp>(x: T): string; }): any; (x: typeof b): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>foo4 : { (x: { "new"<T extends RegExp>(x: T): string; }): any; (x: typeof b): any; }
+>x : { "new"<T extends RegExp>(x: T): string; }
+>b : { "new"<T extends RegExp>(x: T): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T extends RegExp>(x: T): string; }): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo4 : { (x: { "new"<T extends RegExp>(x: T): string; }): any; (x: { "new"<T extends RegExp>(x: T): string; }): any; }
 >x : any
 
 function foo8(x: B<Array<number>>);
@@ -142,16 +142,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Array<number>>);
->foo11 : { (x: B<Array<number>>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo11 : { (x: B<Array<number>>): any; (x: { "new"<T extends RegExp>(x: T): string; }): any; }
 >x : B<number[]>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<number[]>): any; (x: typeof b): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>x : { "new"<T extends RegExp>(x: T): string; }
+>b : { "new"<T extends RegExp>(x: T): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<number[]>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo11 : { (x: B<number[]>): any; (x: { "new"<T extends RegExp>(x: T): string; }): any; }
 >x : any
 
 function foo12(x: I<Number>);
@@ -192,15 +192,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Number>);
->foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo14 : { (x: I<Number>): any; (x: { "new"<T extends RegExp>(x: T): string; }): any; }
 >x : I<Number>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<Number>): any; (x: typeof b): any; }
->x : { new<T extends RegExp>(x: T): string; }
->b : { new<T extends RegExp>(x: T): string; }
+>x : { "new"<T extends RegExp>(x: T): string; }
+>b : { "new"<T extends RegExp>(x: T): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Number>): any; (x: { new<T extends RegExp>(x: T): string; }): any; }
+>foo14 : { (x: I<Number>): any; (x: { "new"<T extends RegExp>(x: T): string; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types
index 32ccfc172bf7e..f356abc56a9f7 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints2.types
@@ -47,8 +47,8 @@ var a: { new<T extends U, U extends Array<string>>(x: T, y: U): string }
 >y : U
 
 var b = { new<T extends U, U extends RegExp>(x: T, y: U) { return ''; } }; // not a construct signature, function called new
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->{ new<T extends U, U extends RegExp>(x: T, y: U) { return ''; } } : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
+>{ new<T extends U, U extends RegExp>(x: T, y: U) { return ''; } } : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
 >new : <T extends U, U extends RegExp>(x: T, y: U) => string
 >x : T
 >y : U
@@ -105,17 +105,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>x : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: typeof b): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>foo4 : { (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: typeof b): any; }
+>x : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo4 : { (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo5c(x: C<String, String>);
@@ -180,16 +180,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Array<number>, Array<number>>);
->foo11 : { (x: B<Array<number>, Array<number>>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<Array<number>, Array<number>>): any; (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
 >x : B<number[], number[]>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<number[], number[]>): any; (x: typeof b): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>x : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<number[], number[]>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<number[], number[]>): any; (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo12(x: I<Number, Number>);
@@ -230,15 +230,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Number, Number>);
->foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Number, Number>): any; (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
 >x : I<Number, Number>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<Number, Number>): any; (x: typeof b): any; }
->x : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
->b : { new<T extends U, U extends RegExp>(x: T, y: U): string; }
+>x : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Number, Number>): any; (x: { new<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Number, Number>): any; (x: { "new"<T extends U, U extends RegExp>(x: T, y: U): string; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints3.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints3.types
index bf97ae6b02c1b..02e645c133426 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints3.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints3.types
@@ -67,8 +67,8 @@ var a: { new<T extends U, U extends One>(x: T, y: U): string }
 >y : U
 
 var b = { new<T extends U, U extends Two>(x: T, y: U) { return ''; } }; // not a construct signature, function called new
->b : { new<T extends U, U extends Two>(x: T, y: U): string; }
->{ new<T extends U, U extends Two>(x: T, y: U) { return ''; } } : { new<T extends U, U extends Two>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
+>{ new<T extends U, U extends Two>(x: T, y: U) { return ''; } } : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
 >new : <T extends U, U extends Two>(x: T, y: U) => string
 >x : T
 >y : U
@@ -125,17 +125,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; }
->x : { new<T extends U, U extends Two>(x: T, y: U): string; }
->b : { new<T extends U, U extends Two>(x: T, y: U): string; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; }
+>x : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; (x: typeof b): any; }
->x : { new<T extends U, U extends Two>(x: T, y: U): string; }
->b : { new<T extends U, U extends Two>(x: T, y: U): string; }
+>foo4 : { (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; (x: typeof b): any; }
+>x : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; }
+>foo4 : { (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo5c(x: C<Three, Three>);
@@ -200,16 +200,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Two, Two>);
->foo11 : { (x: B<Two, Two>): any; (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<Two, Two>): any; (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; }
 >x : B<Two, Two>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<Two, Two>): any; (x: typeof b): any; }
->x : { new<T extends U, U extends Two>(x: T, y: U): string; }
->b : { new<T extends U, U extends Two>(x: T, y: U): string; }
+>x : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<Two, Two>): any; (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; }
+>foo11 : { (x: B<Two, Two>): any; (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; }
 >x : any
 
 function foo12(x: I<Five<string>, Five<string>>);
@@ -250,15 +250,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Five<string>, Five<string>>);
->foo14 : { (x: I<Five<string>, Five<string>>): any; (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Five<string>, Five<string>>): any; (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; }
 >x : I<Five<string>, Five<string>>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<Five<string>, Five<string>>): any; (x: typeof b): any; }
->x : { new<T extends U, U extends Two>(x: T, y: U): string; }
->b : { new<T extends U, U extends Two>(x: T, y: U): string; }
+>x : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
+>b : { "new"<T extends U, U extends Two>(x: T, y: U): string; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Five<string>, Five<string>>): any; (x: { new<T extends U, U extends Two>(x: T, y: U): string; }): any; }
+>foo14 : { (x: I<Five<string>, Five<string>>): any; (x: { "new"<T extends U, U extends Two>(x: T, y: U): string; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types
index 6c35b07b35179..6fae02bf0cd03 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.types
@@ -34,8 +34,8 @@ var a: { new<T>(x: T): T }
 >x : T
 
 var b = { new<T>(x: T): T { return null; } }; // not a construct signature, function called new
->b : { new<T>(x: T): T; }
->{ new<T>(x: T): T { return null; } } : { new<T>(x: T): T; }
+>b : { "new"<T>(x: T): T; }
+>{ new<T>(x: T): T { return null; } } : { "new"<T>(x: T): T; }
 >new : <T>(x: T) => T
 >x : T
 
@@ -90,31 +90,31 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T>(x: T): T; }): any; }
->x : { new<T>(x: T): T; }
->b : { new<T>(x: T): T; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T>(x: T): T; }): any; }
+>x : { "new"<T>(x: T): T; }
+>b : { "new"<T>(x: T): T; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T>(x: T): T; }): any; (x: typeof b): any; }
->x : { new<T>(x: T): T; }
->b : { new<T>(x: T): T; }
+>foo4 : { (x: { "new"<T>(x: T): T; }): any; (x: typeof b): any; }
+>x : { "new"<T>(x: T): T; }
+>b : { "new"<T>(x: T): T; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T>(x: T): T; }): any; (x: { new<T>(x: T): T; }): any; }
+>foo4 : { (x: { "new"<T>(x: T): T; }): any; (x: { "new"<T>(x: T): T; }): any; }
 >x : any
 
 function foo5(x: typeof a): number;
->foo5 : { (x: typeof a): number; (x: { new<T>(x: T): T; }): string; }
+>foo5 : { (x: typeof a): number; (x: { "new"<T>(x: T): T; }): string; }
 >x : new <T>(x: T) => T
 >a : new <T>(x: T) => T
 
 function foo5(x: typeof b): string; // ok
 >foo5 : { (x: new <T>(x: T) => T): number; (x: typeof b): string; }
->x : { new<T>(x: T): T; }
->b : { new<T>(x: T): T; }
+>x : { "new"<T>(x: T): T; }
+>b : { "new"<T>(x: T): T; }
 
 function foo5(x: any): any { }
->foo5 : { (x: new <T>(x: T) => T): number; (x: { new<T>(x: T): T; }): string; }
+>foo5 : { (x: new <T>(x: T) => T): number; (x: { "new"<T>(x: T): T; }): string; }
 >x : any
 
 function foo8(x: B<string>);
@@ -155,16 +155,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<string>);
->foo11 : { (x: B<string>): any; (x: { new<T>(x: T): T; }): any; }
+>foo11 : { (x: B<string>): any; (x: { "new"<T>(x: T): T; }): any; }
 >x : B<string>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<string>): any; (x: typeof b): any; }
->x : { new<T>(x: T): T; }
->b : { new<T>(x: T): T; }
+>x : { "new"<T>(x: T): T; }
+>b : { "new"<T>(x: T): T; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<string>): any; (x: { new<T>(x: T): T; }): any; }
+>foo11 : { (x: B<string>): any; (x: { "new"<T>(x: T): T; }): any; }
 >x : any
 
 function foo12(x: I<string>);
@@ -205,16 +205,16 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<string>);
->foo14 : { (x: I<string>): any; (x: { new<T>(x: T): T; }): any; }
+>foo14 : { (x: I<string>): any; (x: { "new"<T>(x: T): T; }): any; }
 >x : I<string>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<string>): any; (x: typeof b): any; }
->x : { new<T>(x: T): T; }
->b : { new<T>(x: T): T; }
+>x : { "new"<T>(x: T): T; }
+>b : { "new"<T>(x: T): T; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string>): any; (x: { new<T>(x: T): T; }): any; }
+>foo14 : { (x: I<string>): any; (x: { "new"<T>(x: T): T; }): any; }
 >x : any
 
 function foo15(x: I2);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types
index 1d95296be6e2c..09002456b70ee 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.types
@@ -34,8 +34,8 @@ var a: { new<T extends Date>(x: T): T }
 >x : T
 
 var b = { new<T extends Date>(x: T) { return null; } }; // not a construct signature, function called new
->b : { new<T extends Date>(x: T): any; }
->{ new<T extends Date>(x: T) { return null; } } : { new<T extends Date>(x: T): any; }
+>b : { "new"<T extends Date>(x: T): any; }
+>{ new<T extends Date>(x: T) { return null; } } : { "new"<T extends Date>(x: T): any; }
 >new : <T extends Date>(x: T) => any
 >x : T
 
@@ -90,17 +90,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T extends Date>(x: T): any; }): any; }
->x : { new<T extends Date>(x: T): any; }
->b : { new<T extends Date>(x: T): any; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T extends Date>(x: T): any; }): any; }
+>x : { "new"<T extends Date>(x: T): any; }
+>b : { "new"<T extends Date>(x: T): any; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T extends Date>(x: T): any; }): any; (x: typeof b): any; }
->x : { new<T extends Date>(x: T): any; }
->b : { new<T extends Date>(x: T): any; }
+>foo4 : { (x: { "new"<T extends Date>(x: T): any; }): any; (x: typeof b): any; }
+>x : { "new"<T extends Date>(x: T): any; }
+>b : { "new"<T extends Date>(x: T): any; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T extends Date>(x: T): any; }): any; (x: { new<T extends Date>(x: T): any; }): any; }
+>foo4 : { (x: { "new"<T extends Date>(x: T): any; }): any; (x: { "new"<T extends Date>(x: T): any; }): any; }
 >x : any
 
 function foo8(x: B<Date>);
@@ -141,16 +141,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<Date>);
->foo11 : { (x: B<Date>): any; (x: { new<T extends Date>(x: T): any; }): any; }
+>foo11 : { (x: B<Date>): any; (x: { "new"<T extends Date>(x: T): any; }): any; }
 >x : B<Date>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<Date>): any; (x: typeof b): any; }
->x : { new<T extends Date>(x: T): any; }
->b : { new<T extends Date>(x: T): any; }
+>x : { "new"<T extends Date>(x: T): any; }
+>b : { "new"<T extends Date>(x: T): any; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<Date>): any; (x: { new<T extends Date>(x: T): any; }): any; }
+>foo11 : { (x: B<Date>): any; (x: { "new"<T extends Date>(x: T): any; }): any; }
 >x : any
 
 function foo12(x: I<Date>);
@@ -191,16 +191,16 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<Date>);
->foo14 : { (x: I<Date>): any; (x: { new<T extends Date>(x: T): any; }): any; }
+>foo14 : { (x: I<Date>): any; (x: { "new"<T extends Date>(x: T): any; }): any; }
 >x : I<Date>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<Date>): any; (x: typeof b): any; }
->x : { new<T extends Date>(x: T): any; }
->b : { new<T extends Date>(x: T): any; }
+>x : { "new"<T extends Date>(x: T): any; }
+>b : { "new"<T extends Date>(x: T): any; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<Date>): any; (x: { new<T extends Date>(x: T): any; }): any; }
+>foo14 : { (x: I<Date>): any; (x: { "new"<T extends Date>(x: T): any; }): any; }
 >x : any
 
 function foo15(x: I2);
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types
index a498c166bc9bf..477e469cc1482 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.types
@@ -32,8 +32,8 @@ var a: { new <Z, A, B, CC, D>(x: Z): C<Z, A, B>; }
 >x : Z
 
 var b = { new<A, B, C, D, E, F>(x: A) { return x; } };
->b : { new<A, B, C, D, E, F>(x: A): A; }
->{ new<A, B, C, D, E, F>(x: A) { return x; } } : { new<A, B, C, D, E, F>(x: A): A; }
+>b : { "new"<A, B, C, D, E, F>(x: A): A; }
+>{ new<A, B, C, D, E, F>(x: A) { return x; } } : { "new"<A, B, C, D, E, F>(x: A): A; }
 >new : <A, B, C, D, E, F>(x: A) => A
 >x : A
 >x : A
@@ -89,17 +89,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
->x : { new<A, B, C, D, E, F>(x: A): A; }
->b : { new<A, B, C, D, E, F>(x: A): A; }
+>foo4 : { (x: typeof b): any; (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; }
+>x : { "new"<A, B, C, D, E, F>(x: A): A; }
+>b : { "new"<A, B, C, D, E, F>(x: A): A; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<A, B, C, D, E, F>(x: A): A; }): any; (x: typeof b): any; }
->x : { new<A, B, C, D, E, F>(x: A): A; }
->b : { new<A, B, C, D, E, F>(x: A): A; }
+>foo4 : { (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; (x: typeof b): any; }
+>x : { "new"<A, B, C, D, E, F>(x: A): A; }
+>b : { "new"<A, B, C, D, E, F>(x: A): A; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<A, B, C, D, E, F>(x: A): A; }): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo4 : { (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : any
 
 function foo8(x: B<string, string>);
@@ -140,16 +140,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<string, boolean>);
->foo11 : { (x: B<string, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo11 : { (x: B<string, boolean>): any; (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : B<string, boolean>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<string, boolean>): any; (x: typeof b): any; }
->x : { new<A, B, C, D, E, F>(x: A): A; }
->b : { new<A, B, C, D, E, F>(x: A): A; }
+>x : { "new"<A, B, C, D, E, F>(x: A): A; }
+>b : { "new"<A, B, C, D, E, F>(x: A): A; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<string, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo11 : { (x: B<string, boolean>): any; (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : any
 
 function foo12(x: I<B<string, number>, number, Date, string>);
@@ -190,15 +190,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<string, Date, RegExp, boolean>);
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : I<string, Date, RegExp, boolean>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: typeof b): any; }
->x : { new<A, B, C, D, E, F>(x: A): A; }
->b : { new<A, B, C, D, E, F>(x: A): A; }
+>x : { "new"<A, B, C, D, E, F>(x: A): A; }
+>b : { "new"<A, B, C, D, E, F>(x: A): A; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { new<A, B, C, D, E, F>(x: A): A; }): any; }
+>foo14 : { (x: I<string, Date, RegExp, boolean>): any; (x: { "new"<A, B, C, D, E, F>(x: A): A; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.types
index 9e5e401ce5ac3..64b2d8ca3795f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterNames.types
@@ -32,8 +32,8 @@ var a: { new<Z>(x: Z): B<Z> }
 >x : Z
 
 var b = { new<A>(x: A) { return new C<A>(x); } };
->b : { new<A>(x: A): C<A>; }
->{ new<A>(x: A) { return new C<A>(x); } } : { new<A>(x: A): C<A>; }
+>b : { "new"<A>(x: A): C<A>; }
+>{ new<A>(x: A) { return new C<A>(x); } } : { "new"<A>(x: A): C<A>; }
 >new : <A>(x: A) => C<A>
 >x : A
 >new C<A>(x) : C<A>
@@ -91,17 +91,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<A>(x: A): C<A>; }): any; }
->x : { new<A>(x: A): C<A>; }
->b : { new<A>(x: A): C<A>; }
+>foo4 : { (x: typeof b): any; (x: { "new"<A>(x: A): C<A>; }): any; }
+>x : { "new"<A>(x: A): C<A>; }
+>b : { "new"<A>(x: A): C<A>; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<A>(x: A): C<A>; }): any; (x: typeof b): any; }
->x : { new<A>(x: A): C<A>; }
->b : { new<A>(x: A): C<A>; }
+>foo4 : { (x: { "new"<A>(x: A): C<A>; }): any; (x: typeof b): any; }
+>x : { "new"<A>(x: A): C<A>; }
+>b : { "new"<A>(x: A): C<A>; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<A>(x: A): C<A>; }): any; (x: { new<A>(x: A): C<A>; }): any; }
+>foo4 : { (x: { "new"<A>(x: A): C<A>; }): any; (x: { "new"<A>(x: A): C<A>; }): any; }
 >x : any
 
 function foo8(x: B<string>);
@@ -142,16 +142,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<string>);
->foo11 : { (x: B<string>): any; (x: { new<A>(x: A): C<A>; }): any; }
+>foo11 : { (x: B<string>): any; (x: { "new"<A>(x: A): C<A>; }): any; }
 >x : B<string>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<string>): any; (x: typeof b): any; }
->x : { new<A>(x: A): C<A>; }
->b : { new<A>(x: A): C<A>; }
+>x : { "new"<A>(x: A): C<A>; }
+>b : { "new"<A>(x: A): C<A>; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<string>): any; (x: { new<A>(x: A): C<A>; }): any; }
+>foo11 : { (x: B<string>): any; (x: { "new"<A>(x: A): C<A>; }): any; }
 >x : any
 
 function foo12(x: I<string>);
@@ -192,15 +192,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<string>);
->foo14 : { (x: I<string>): any; (x: { new<A>(x: A): C<A>; }): any; }
+>foo14 : { (x: I<string>): any; (x: { "new"<A>(x: A): C<A>; }): any; }
 >x : I<string>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<string>): any; (x: typeof b): any; }
->x : { new<A>(x: A): C<A>; }
->b : { new<A>(x: A): C<A>; }
+>x : { "new"<A>(x: A): C<A>; }
+>b : { "new"<A>(x: A): C<A>; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string>): any; (x: { new<A>(x: A): C<A>; }): any; }
+>foo14 : { (x: I<string>): any; (x: { "new"<A>(x: A): C<A>; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.types
index 2fc3493fae3b1..f07a9f58d6e9f 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams.types
@@ -39,8 +39,8 @@ var a: { new<T>(x: T, y?: T): B<T> }
 >y : T
 
 var b = { new<T>(x: T, y?: T) { return new C<T>(x, y); } }; // not a construct signature, function called new
->b : { new<T>(x: T, y?: T): C<T>; }
->{ new<T>(x: T, y?: T) { return new C<T>(x, y); } } : { new<T>(x: T, y?: T): C<T>; }
+>b : { "new"<T>(x: T, y?: T): C<T>; }
+>{ new<T>(x: T, y?: T) { return new C<T>(x, y); } } : { "new"<T>(x: T, y?: T): C<T>; }
 >new : <T>(x: T, y?: T) => C<T>
 >x : T
 >y : T
@@ -100,17 +100,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T>(x: T, y?: T): C<T>; }): any; }
->x : { new<T>(x: T, y?: T): C<T>; }
->b : { new<T>(x: T, y?: T): C<T>; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T>(x: T, y?: T): C<T>; }): any; }
+>x : { "new"<T>(x: T, y?: T): C<T>; }
+>b : { "new"<T>(x: T, y?: T): C<T>; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T>(x: T, y?: T): C<T>; }): any; (x: typeof b): any; }
->x : { new<T>(x: T, y?: T): C<T>; }
->b : { new<T>(x: T, y?: T): C<T>; }
+>foo4 : { (x: { "new"<T>(x: T, y?: T): C<T>; }): any; (x: typeof b): any; }
+>x : { "new"<T>(x: T, y?: T): C<T>; }
+>b : { "new"<T>(x: T, y?: T): C<T>; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T>(x: T, y?: T): C<T>; }): any; (x: { new<T>(x: T, y?: T): C<T>; }): any; }
+>foo4 : { (x: { "new"<T>(x: T, y?: T): C<T>; }): any; (x: { "new"<T>(x: T, y?: T): C<T>; }): any; }
 >x : any
 
 function foo8(x: B<string>): string;
@@ -151,16 +151,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<string>);
->foo11 : { (x: B<string>): any; (x: { new<T>(x: T, y?: T): C<T>; }): any; }
+>foo11 : { (x: B<string>): any; (x: { "new"<T>(x: T, y?: T): C<T>; }): any; }
 >x : B<string>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<string>): any; (x: typeof b): any; }
->x : { new<T>(x: T, y?: T): C<T>; }
->b : { new<T>(x: T, y?: T): C<T>; }
+>x : { "new"<T>(x: T, y?: T): C<T>; }
+>b : { "new"<T>(x: T, y?: T): C<T>; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<string>): any; (x: { new<T>(x: T, y?: T): C<T>; }): any; }
+>foo11 : { (x: B<string>): any; (x: { "new"<T>(x: T, y?: T): C<T>; }): any; }
 >x : any
 
 function foo12(x: I<string>);
@@ -201,15 +201,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<string>);
->foo14 : { (x: I<string>): any; (x: { new<T>(x: T, y?: T): C<T>; }): any; }
+>foo14 : { (x: I<string>): any; (x: { "new"<T>(x: T, y?: T): C<T>; }): any; }
 >x : I<string>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<string>): any; (x: typeof b): any; }
->x : { new<T>(x: T, y?: T): C<T>; }
->b : { new<T>(x: T, y?: T): C<T>; }
+>x : { "new"<T>(x: T, y?: T): C<T>; }
+>b : { "new"<T>(x: T, y?: T): C<T>; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string>): any; (x: { new<T>(x: T, y?: T): C<T>; }): any; }
+>foo14 : { (x: I<string>): any; (x: { "new"<T>(x: T, y?: T): C<T>; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.types
index f629ad0673838..79967629250e4 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams2.types
@@ -39,8 +39,8 @@ var a: { new<T, U>(x: T, y?: U): B<T,U> }
 >y : U
 
 var b = { new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } }; // not a construct signature, function called new
->b : { new<T, U>(x: T, y?: U): C<T, U>; }
->{ new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } } : { new<T, U>(x: T, y?: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y?: U): C<T, U>; }
+>{ new<T, U>(x: T, y?: U) { return new C<T, U>(x, y); } } : { "new"<T, U>(x: T, y?: U): C<T, U>; }
 >new : <T, U>(x: T, y?: U) => C<T, U>
 >x : T
 >y : U
@@ -100,17 +100,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; }
->x : { new<T, U>(x: T, y?: U): C<T, U>; }
->b : { new<T, U>(x: T, y?: U): C<T, U>; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; }
+>x : { "new"<T, U>(x: T, y?: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y?: U): C<T, U>; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; (x: typeof b): any; }
->x : { new<T, U>(x: T, y?: U): C<T, U>; }
->b : { new<T, U>(x: T, y?: U): C<T, U>; }
+>foo4 : { (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; (x: typeof b): any; }
+>x : { "new"<T, U>(x: T, y?: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y?: U): C<T, U>; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; }
+>foo4 : { (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; }
 >x : any
 
 function foo8(x: B<string, number>);
@@ -151,16 +151,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<string, number>);
->foo11 : { (x: B<string, number>): any; (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; }
+>foo11 : { (x: B<string, number>): any; (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; }
 >x : B<string, number>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<string, number>): any; (x: typeof b): any; }
->x : { new<T, U>(x: T, y?: U): C<T, U>; }
->b : { new<T, U>(x: T, y?: U): C<T, U>; }
+>x : { "new"<T, U>(x: T, y?: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y?: U): C<T, U>; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<string, number>): any; (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; }
+>foo11 : { (x: B<string, number>): any; (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; }
 >x : any
 
 function foo12(x: I<string, number>);
@@ -201,15 +201,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<string, number>);
->foo14 : { (x: I<string, number>): any; (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; }
+>foo14 : { (x: I<string, number>): any; (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; }
 >x : I<string, number>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<string, number>): any; (x: typeof b): any; }
->x : { new<T, U>(x: T, y?: U): C<T, U>; }
->b : { new<T, U>(x: T, y?: U): C<T, U>; }
+>x : { "new"<T, U>(x: T, y?: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y?: U): C<T, U>; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string, number>): any; (x: { new<T, U>(x: T, y?: U): C<T, U>; }): any; }
+>foo14 : { (x: I<string, number>): any; (x: { "new"<T, U>(x: T, y?: U): C<T, U>; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.types b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.types
index 5917ef0e0ae11..9d1c287e6e356 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.types
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesOptionalParams3.types
@@ -39,8 +39,8 @@ var a: { new <T, U>(x: T, y?: U): B<T, U> };
 >y : U
 
 var b = { new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } }; // not a construct signature, function called new
->b : { new<T, U>(x: T, y: U): C<T, U>; }
->{ new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } } : { new<T, U>(x: T, y: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y: U): C<T, U>; }
+>{ new<T, U>(x: T, y: U) { return new C<T, U>(x, y); } } : { "new"<T, U>(x: T, y: U): C<T, U>; }
 >new : <T, U>(x: T, y: U) => C<T, U>
 >x : T
 >y : U
@@ -100,17 +100,17 @@ function foo3(x: any) { }
 >x : any
 
 function foo4(x: typeof b);
->foo4 : { (x: typeof b): any; (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; }
->x : { new<T, U>(x: T, y: U): C<T, U>; }
->b : { new<T, U>(x: T, y: U): C<T, U>; }
+>foo4 : { (x: typeof b): any; (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; }
+>x : { "new"<T, U>(x: T, y: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y: U): C<T, U>; }
 
 function foo4(x: typeof b); // error
->foo4 : { (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; (x: typeof b): any; }
->x : { new<T, U>(x: T, y: U): C<T, U>; }
->b : { new<T, U>(x: T, y: U): C<T, U>; }
+>foo4 : { (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; (x: typeof b): any; }
+>x : { "new"<T, U>(x: T, y: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y: U): C<T, U>; }
 
 function foo4(x: any) { }
->foo4 : { (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; }
+>foo4 : { (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; }
 >x : any
 
 function foo8(x: B<string, number>);
@@ -151,16 +151,16 @@ function foo10(x: any) { }
 >x : any
 
 function foo11(x: B<string, number>);
->foo11 : { (x: B<string, number>): any; (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; }
+>foo11 : { (x: B<string, number>): any; (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; }
 >x : B<string, number>
 
 function foo11(x: typeof b); // ok
 >foo11 : { (x: B<string, number>): any; (x: typeof b): any; }
->x : { new<T, U>(x: T, y: U): C<T, U>; }
->b : { new<T, U>(x: T, y: U): C<T, U>; }
+>x : { "new"<T, U>(x: T, y: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y: U): C<T, U>; }
 
 function foo11(x: any) { }
->foo11 : { (x: B<string, number>): any; (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; }
+>foo11 : { (x: B<string, number>): any; (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; }
 >x : any
 
 function foo12(x: I<string, number>);
@@ -201,15 +201,15 @@ function foo13(x: any) { }
 >x : any
 
 function foo14(x: I<string, number>);
->foo14 : { (x: I<string, number>): any; (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; }
+>foo14 : { (x: I<string, number>): any; (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; }
 >x : I<string, number>
 
 function foo14(x: typeof b); // ok
 >foo14 : { (x: I<string, number>): any; (x: typeof b): any; }
->x : { new<T, U>(x: T, y: U): C<T, U>; }
->b : { new<T, U>(x: T, y: U): C<T, U>; }
+>x : { "new"<T, U>(x: T, y: U): C<T, U>; }
+>b : { "new"<T, U>(x: T, y: U): C<T, U>; }
 
 function foo14(x: any) { }
->foo14 : { (x: I<string, number>): any; (x: { new<T, U>(x: T, y: U): C<T, U>; }): any; }
+>foo14 : { (x: I<string, number>): any; (x: { "new"<T, U>(x: T, y: U): C<T, U>; }): any; }
 >x : any
 
diff --git a/tests/baselines/reference/parser645484.types b/tests/baselines/reference/parser645484.types
index 290fb19fcc9f8..7dcf7f95eca7b 100644
--- a/tests/baselines/reference/parser645484.types
+++ b/tests/baselines/reference/parser645484.types
@@ -2,7 +2,7 @@
 
 === parser645484.ts ===
 var c : {
->c : { new?(): any; }
+>c : { "new"?(): any; }
 
     new?(): any;
 >new : () => any
diff --git a/tests/baselines/reference/vardecl.js b/tests/baselines/reference/vardecl.js
index 1356ade167d92..77fbc628e8483 100644
--- a/tests/baselines/reference/vardecl.js
+++ b/tests/baselines/reference/vardecl.js
@@ -194,7 +194,7 @@ declare var n1: {
     [s: string]: number;
 };
 declare var c: {
-    new?(): any;
+    "new"?(): any;
 };
 declare var d: {
     foo?(): {
diff --git a/tests/baselines/reference/vardecl.types b/tests/baselines/reference/vardecl.types
index 39ed0dbee7492..1703a6fed1d9a 100644
--- a/tests/baselines/reference/vardecl.types
+++ b/tests/baselines/reference/vardecl.types
@@ -66,7 +66,7 @@ var n1: { [s: string]: number; };
 >s : string
 
 var c : {
->c : { new?(): any; }
+>c : { "new"?(): any; }
 
         new? (): any;
 >new : () => any