correctly parse destructuring in let outside of strict mode

src/compiler/parser.ts

@@ -2975,6 +2975,11 @@ module ts {
             return !scanner.hasPrecedingLineBreak() && isIdentifier()
         }
 
+        function netTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() {
+            nextToken();
+            return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.OpenBracketToken)
+        }
+
         function parseYieldExpression(): YieldExpression {
             var node = <YieldExpression>createNode(SyntaxKind.YieldExpression);
 
@@ -4873,9 +4878,9 @@ module ts {
         }
 
         function isLetDeclaration() {
-            // It is let declaration if in strict mode or next token is identifier on same line.
+            // It is let declaration if in strict mode or next token is identifier\open brace\open curly on same line.
             // otherwise it needs to be treated like identifier
-            return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOnSameLine);
+            return inStrictModeContext() || lookAhead(netTokenIsIdentifierOrStartOfDestructuringOnTheSameLine);
         }
 
         function isDeclarationStart(): boolean {

tests/baselines/reference/letInNonStrictMode.js

@@ -0,0 +1,11 @@
+//// [letInNonStrictMode.ts]
+let [x] = [1];
+let {a: y} = {a: 1};
+
+//// [letInNonStrictMode.js]
+var x = ([
+    1
+])[0];
+var y = ({
+    a: 1
+}).a;

tests/baselines/reference/letInNonStrictMode.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/letInNonStrictMode.ts ===
+let [x] = [1];
+>x : number
+>[1] : [number]
+
+let {a: y} = {a: 1};
+>a : unknown
+>y : number
+>{a: 1} : { a: number; }
+>a : number
+

tests/cases/compiler/letInNonStrictMode.ts

@@ -0,0 +1,2 @@
+let [x] = [1];
+let {a: y} = {a: 1};