diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 2e1407fd064..ed447ab1dd4 100644
--- a/src/compiler/emitter.ts
+++ b/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);
diff --git a/tests/baselines/reference/destructuringWithNewExpression.js b/tests/baselines/reference/destructuringWithNewExpression.js
new file mode 100644
index 00000000000..310129674b1
--- /dev/null
+++ b/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;
diff --git a/tests/baselines/reference/destructuringWithNewExpression.types b/tests/baselines/reference/destructuringWithNewExpression.types
new file mode 100644
index 00000000000..c3e4450461b
--- /dev/null
+++ b/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))
+
diff --git a/tests/baselines/reference/destructuringWithNumberLiteral.js b/tests/baselines/reference/destructuringWithNumberLiteral.js
new file mode 100644
index 00000000000..8804b850cc3
--- /dev/null
+++ b/tests/baselines/reference/destructuringWithNumberLiteral.js
@@ -0,0 +1,5 @@
+//// [destructuringWithNumberLiteral.ts]
+var { toExponential } = 0;
+
+//// [destructuringWithNumberLiteral.js]
+var toExponential = (0).toExponential;
diff --git a/tests/baselines/reference/destructuringWithNumberLiteral.types b/tests/baselines/reference/destructuringWithNumberLiteral.types
new file mode 100644
index 00000000000..9daa6520f88
--- /dev/null
+++ b/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
+
diff --git a/tests/cases/compiler/destructuringWithNewExpression.ts b/tests/cases/compiler/destructuringWithNewExpression.ts
new file mode 100644
index 00000000000..782fef2b54d
--- /dev/null
+++ b/tests/cases/compiler/destructuringWithNewExpression.ts
@@ -0,0 +1,5 @@
+class C {
+    x = 0;
+}
+
+var { x } = new C;
\ No newline at end of file
diff --git a/tests/cases/compiler/destructuringWithNumberLiteral.ts b/tests/cases/compiler/destructuringWithNumberLiteral.ts
new file mode 100644
index 00000000000..b0371c7c510
--- /dev/null
+++ b/tests/cases/compiler/destructuringWithNumberLiteral.ts
@@ -0,0 +1 @@
+var { toExponential } = 0;
\ No newline at end of file