Object spread

Jakefile.js

@@ -71,6 +71,7 @@ var compilerSources = [
     "transformers/destructuring.ts",
     "transformers/ts.ts",
     "transformers/jsx.ts",
+    "transformers/esnext.ts",
     "transformers/es2017.ts",
     "transformers/es2016.ts",
     "transformers/es2015.ts",
@@ -107,6 +108,7 @@ var servicesSources = [
     "transformers/destructuring.ts",
     "transformers/ts.ts",
     "transformers/jsx.ts",
+    "transformers/esnext.ts",
     "transformers/es2017.ts",
     "transformers/es2016.ts",
     "transformers/es2015.ts",

src/compiler/binder.ts

@@ -1138,8 +1138,8 @@ namespace ts {
             }
             else if (node.kind === SyntaxKind.ArrayLiteralExpression) {
                 for (const e of (<ArrayLiteralExpression>node).elements) {
-                    if (e.kind === SyntaxKind.SpreadElementExpression) {
-                        bindAssignmentTargetFlow((<SpreadElementExpression>e).expression);
+                    if (e.kind === SyntaxKind.SpreadExpression) {
+                        bindAssignmentTargetFlow((<SpreadExpression>e).expression);
                     }
                     else {
                         bindDestructuringTargetFlow(e);
@@ -1154,6 +1154,9 @@ namespace ts {
                     else if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
                         bindAssignmentTargetFlow((<ShorthandPropertyAssignment>p).name);
                     }
+                    else if (p.kind === SyntaxKind.SpreadElementExpression) {
+                        bindAssignmentTargetFlow((<SpreadElementExpression>p).expression);
+                    }
                 }
             }
         }
@@ -1926,8 +1929,9 @@ namespace ts {
                 case SyntaxKind.EnumMember:
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
 
+                case SyntaxKind.SpreadElementExpression:
                 case SyntaxKind.JsxSpreadAttribute:
-                    emitFlags |= NodeFlags.HasJsxSpreadAttributes;
+                    emitFlags |= NodeFlags.HasSpreadAttribute;
                     return;
 
                 case SyntaxKind.CallSignature:
@@ -2492,9 +2496,9 @@ namespace ts {
             transformFlags |= TransformFlags.AssertTypeScript;
         }
 
-        if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression
+        if (subtreeFlags & TransformFlags.ContainsSpreadExpression
             || isSuperOrSuperProperty(expression, expressionKind)) {
-            // If the this node contains a SpreadElementExpression, or is a super call, then it is an ES6
+            // If the this node contains a SpreadExpression, or is a super call, then it is an ES6
             // node.
             transformFlags |= TransformFlags.AssertES2015;
         }
@@ -2523,7 +2527,7 @@ namespace ts {
         if (node.typeArguments) {
             transformFlags |= TransformFlags.AssertTypeScript;
         }
-        if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
+        if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
             // If the this node contains a SpreadElementExpression then it is an ES6
             // node.
             transformFlags |= TransformFlags.AssertES2015;
@@ -3123,9 +3127,10 @@ namespace ts {
                 }
                 break;
 
+            case SyntaxKind.SpreadExpression:
             case SyntaxKind.SpreadElementExpression:
-                // This node is ES6 syntax, but is handled by a containing node.
-                transformFlags |= TransformFlags.ContainsSpreadElementExpression;
+                // This node is ES6 or ES future syntax, but is handled by a containing node.
+                transformFlags |= TransformFlags.ContainsSpreadExpression;
                 break;
 
             case SyntaxKind.SuperKeyword:
@@ -3163,13 +3168,19 @@ namespace ts {
                     transformFlags |= TransformFlags.ContainsLexicalThis;
                 }
 
+                if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
+                    // If an ObjectLiteralExpression contains a spread element, then it
+                    // is an ES next node.
+                    transformFlags |= TransformFlags.AssertESNext;
+                }
+
                 break;
 
             case SyntaxKind.ArrayLiteralExpression:
             case SyntaxKind.NewExpression:
                 excludeFlags = TransformFlags.ArrayLiteralOrCallOrNewExcludes;
-                if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
-                    // If the this node contains a SpreadElementExpression, then it is an ES6
+                if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
+                    // If the this node contains a SpreadExpression, then it is an ES6
                     // node.
                     transformFlags |= TransformFlags.AssertES2015;
                 }