Fix parenthesizeForAccess to always parenthesize NewExpressions and NumberLiterals

src/compiler/emitter.ts

@@ -1607,7 +1607,15 @@ var __param = this.__param || function(index, decorator) { return function (targ
             }
 
             function parenthesizeForAccess(expr: Expression): LeftHandSideExpression {
-                if (isLeftHandSideExpression(expr)) {
+                // isLeftHandSideExpression is almost the correct criterion for when it is not necessary
+                // to parenthesize the expression before a dot. The known exceptions are:
+                //
+                //    NewExpression:
+                //       new C.x        -> not the same as (new C).x
+                //    NumberLiteral
+                //       1.x            -> not the same as (1).x
+                //
+                if (isLeftHandSideExpression(expr) && expr.kind !== SyntaxKind.NewExpression && expr.kind !== SyntaxKind.NumericLiteral) {
                     return <LeftHandSideExpression>expr;
                 }
                 let node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);

tests/baselines/reference/destructuringWithNewExpression.js

@@ -0,0 +1,15 @@
+//// [destructuringWithNewExpression.ts]
+class C {
+    x = 0;
+}
+
+var { x } = new C;
+
+//// [destructuringWithNewExpression.js]
+var C = (function () {
+    function C() {
+        this.x = 0;
+    }
+    return C;
+})();
+var x = (new C).x;

tests/baselines/reference/destructuringWithNewExpression.types

@@ -0,0 +1,14 @@
+=== tests/cases/compiler/destructuringWithNewExpression.ts ===
+class C {
+>C : C, Symbol(C, Decl(destructuringWithNewExpression.ts, 0, 0))
+
+    x = 0;
+>x : number, Symbol(x, Decl(destructuringWithNewExpression.ts, 0, 9))
+>0 : number
+}
+
+var { x } = new C;
+>x : number, Symbol(x, Decl(destructuringWithNewExpression.ts, 4, 5))
+>new C : C
+>C : typeof C, Symbol(C, Decl(destructuringWithNewExpression.ts, 0, 0))
+

tests/baselines/reference/destructuringWithNumberLiteral.js

@@ -0,0 +1,5 @@
+//// [destructuringWithNumberLiteral.ts]
+var { toExponential } = 0;
+
+//// [destructuringWithNumberLiteral.js]
+var toExponential = (0).toExponential;

tests/baselines/reference/destructuringWithNumberLiteral.types

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/destructuringWithNumberLiteral.ts ===
+var { toExponential } = 0;
+>toExponential : (fractionDigits?: number) => string, Symbol(toExponential, Decl(destructuringWithNumberLiteral.ts, 0, 5))
+>0 : number
+

tests/cases/compiler/destructuringWithNewExpression.ts

@@ -0,0 +1,5 @@
+class C {
+    x = 0;
+}
+
+var { x } = new C;

tests/cases/compiler/destructuringWithNumberLiteral.ts

@@ -0,0 +1 @@
+var { toExponential } = 0;