Added iterationMode switch, consolidate some tests, cleanup

Author: rbuckton

src/compiler/binder.ts

@@ -954,7 +954,7 @@ namespace ts {
             addAntecedent(preLoopLabel, currentFlow);
             currentFlow = preLoopLabel;
             if (node.kind === SyntaxKind.ForOfStatement) {
-                bind(node.modifierToken);
+                bind(node.awaitModifier);
             }
             bind(node.expression);
             addAntecedent(postLoopLabel, currentFlow);
@@ -3125,7 +3125,7 @@ namespace ts {
                 break;
 
             case SyntaxKind.ForOfStatement:
-                if ((<ForOfStatement>node).modifierToken) {
+                if ((<ForOfStatement>node).awaitModifier) {
                     transformFlags |= TransformFlags.AssertES2017;
                 }
 
@@ -3146,17 +3146,10 @@ namespace ts {
 
             case SyntaxKind.ForOfStatement:
                 // This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of).
-                switch (getForOfModifierKind(<ForOfStatement>node)) {
-                    case SyntaxKind.AwaitKeyword:
-                        transformFlags |= TransformFlags.AssertES2017;
-                        break;
-                    case SyntaxKind.EachKeyword:
-                        transformFlags |= TransformFlags.AssertTypeScript;
-                        break;
-                    default:
-                        transformFlags |= TransformFlags.AssertES2015;
-                        break;
+                if ((<ForOfStatement>node).awaitModifier) {
+                    transformFlags |= TransformFlags.AssertES2017;
                 }
+                transformFlags |= TransformFlags.AssertES2015;
                 break;
 
             case SyntaxKind.YieldExpression:

src/compiler/checker.ts

@@ -332,6 +332,15 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
         },
+        {
+            name: "iterationMode",
+            type: createMap({
+                "array": IterationMode.Array,
+                "iterable": IterationMode.Iterable
+            }),
+            description: Diagnostics.Specify_how_to_emit_for_of_spread_and_destructuring_in_ES5_Slash3_Colon_array_arrays_only_default_or_iterable_support_arrays_and_Symbol_iterator,
+            paramType: Diagnostics.MODE
+        },
         {
             name: "baseUrl",
             type: "string",
@@ -436,6 +445,7 @@ namespace ts {
                     "es2017.object": "lib.es2017.object.d.ts",
                     "es2017.sharedmemory": "lib.es2017.sharedmemory.d.ts",
                     "es2017.string": "lib.es2017.string.d.ts",
+                    "es2017.asynciterable": "lib.es2017.asynciterable.d.ts",
                 }),
             },
             description: Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon

src/compiler/commandLineParser.ts

@@ -1391,6 +1391,10 @@ namespace ts {
             getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015 ? ModuleKind.ES2015 : ModuleKind.CommonJS;
     }
 
+    export function getEmitIterationMode(compilerOptions: CompilerOptions) {
+        return getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015 ? IterationMode.Iterable : compilerOptions.iterationMode || IterationMode.Array;
+    }
+
     export function getEmitModuleResolutionKind(compilerOptions: CompilerOptions) {
         let moduleResolution = compilerOptions.moduleResolution;
         if (moduleResolution === undefined) {

src/compiler/core.ts

@@ -2553,6 +2553,10 @@
         "category": "Message",
         "code": 6039
     },
+    "MODE": {
+        "category": "Message",
+        "code": 6040
+    },
     "Compilation complete. Watching for file changes.": {
         "category": "Message",
         "code": 6042
@@ -2689,6 +2693,10 @@
         "category": "Message",
         "code": 6080
     },
+    "Specify how to emit for-of, spread, and destructuring in ES5/3: 'array' (arrays only; default) or 'iterable' (support arrays and Symbol.iterator)": {
+        "category": "Message",
+        "code": 6081
+    },
     "Only 'amd' and 'system' modules are supported alongside --{0}.": {
         "category": "Error",
         "code": 6082

src/compiler/diagnosticMessages.json

@@ -1368,7 +1368,7 @@ namespace ts {
         function emitForOfStatement(node: ForOfStatement) {
             const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
             write(" ");
-            emitWithSuffix(node.modifierToken, " ");
+            emitWithSuffix(node.awaitModifier, " ");
             writeToken(SyntaxKind.OpenParenToken, openParenPos);
             emitForBinding(node.initializer);
             write(" of ");

src/compiler/emitter.ts

@@ -926,17 +926,17 @@ namespace ts {
         return node;
     }
 
-    export function createForOf(modifierToken: AwaitKeywordToken | EachKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement, location?: TextRange) {
+    export function createForOf(modifierToken: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement, location?: TextRange) {
         const node = <ForOfStatement>createNode(SyntaxKind.ForOfStatement, location);
-        node.modifierToken = modifierToken;
+        node.awaitModifier = modifierToken;
         node.initializer = initializer;
         node.expression = expression;
         node.statement = statement;
         return node;
     }
 
-    export function updateForOf(node: ForOfStatement, modifierToken: AwaitKeywordToken | EachKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement) {
-        if (node.modifierToken !== modifierToken || node.initializer !== initializer || node.expression !== expression || node.statement !== statement) {
+    export function updateForOf(node: ForOfStatement, modifierToken: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement) {
+        if (node.awaitModifier !== modifierToken || node.initializer !== initializer || node.expression !== expression || node.statement !== statement) {
             return updateNode(createForOf(modifierToken, initializer, expression, statement, node), node);
         }
         return node;

src/compiler/factory.ts

@@ -240,7 +240,7 @@ namespace ts {
                     visitNode(cbNode, (<ForInStatement>node).expression) ||
                     visitNode(cbNode, (<ForInStatement>node).statement);
             case SyntaxKind.ForOfStatement:
-                return visitNode(cbNode, (<ForOfStatement>node).modifierToken) ||
+                return visitNode(cbNode, (<ForOfStatement>node).awaitModifier) ||
                     visitNode(cbNode, (<ForOfStatement>node).initializer) ||
                     visitNode(cbNode, (<ForOfStatement>node).expression) ||
                     visitNode(cbNode, (<ForOfStatement>node).statement);
@@ -4427,7 +4427,7 @@ namespace ts {
         function parseForOrForInOrForOfStatement(): Statement {
             const pos = getNodePos();
             parseExpected(SyntaxKind.ForKeyword);
-            const modifierToken = parseOptionalToken(SyntaxKind.AwaitKeyword) || parseOptionalToken(SyntaxKind.EachKeyword);
+            const awaitToken = parseOptionalToken(SyntaxKind.AwaitKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
 
             let initializer: VariableDeclarationList | Expression = undefined;
@@ -4440,9 +4440,9 @@ namespace ts {
                 }
             }
             let forOrForInOrForOfStatement: IterationStatement;
-            if (modifierToken ? parseExpected(SyntaxKind.OfKeyword) : parseOptional(SyntaxKind.OfKeyword)) {
+            if (awaitToken ? parseExpected(SyntaxKind.OfKeyword) : parseOptional(SyntaxKind.OfKeyword)) {
                 const forOfStatement = <ForOfStatement>createNode(SyntaxKind.ForOfStatement, pos);
-                forOfStatement.modifierToken = modifierToken;
+                forOfStatement.awaitModifier = awaitToken;
                 forOfStatement.initializer = initializer;
                 forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
                 parseExpected(SyntaxKind.CloseParenToken);

src/compiler/parser.ts

@@ -126,7 +126,6 @@ namespace ts {
         "yield": SyntaxKind.YieldKeyword,
         "async": SyntaxKind.AsyncKeyword,
         "await": SyntaxKind.AwaitKeyword,
-        "each": SyntaxKind.EachKeyword,
         "of": SyntaxKind.OfKeyword,
         "{": SyntaxKind.OpenBraceToken,
         "}": SyntaxKind.CloseBraceToken,

src/compiler/scanner.ts

@@ -6,6 +6,7 @@ namespace ts {
     interface FlattenContext {
         context: TransformationContext;
         level: FlattenLevel;
+        iterationMode: IterationMode;
         hoistTempVariables: boolean;
         emitExpression: (value: Expression) => void;
         emitBindingOrAssignment: (target: BindingOrAssignmentElementTarget, value: Expression, location: TextRange, original: Node) => void;
@@ -57,6 +58,7 @@ namespace ts {
         const flattenContext: FlattenContext = {
             context,
             level,
+            iterationMode: getEmitIterationMode(context.getCompilerOptions()),
             hoistTempVariables: true,
             emitExpression,
             emitBindingOrAssignment,
@@ -143,6 +145,7 @@ namespace ts {
         const flattenContext: FlattenContext = {
             context,
             level,
+            iterationMode: getEmitIterationMode(context.getCompilerOptions()),
             hoistTempVariables,
             emitExpression,
             emitBindingOrAssignment,
@@ -308,7 +311,7 @@ namespace ts {
     function flattenArrayBindingOrAssignmentPattern(flattenContext: FlattenContext, parent: BindingOrAssignmentElement, pattern: ArrayBindingOrAssignmentPattern, value: Expression, location: TextRange) {
         const elements = getElementsOfBindingOrAssignmentPattern(pattern);
         const numElements = elements.length;
-        if (flattenContext.level < FlattenLevel.ObjectRest && !isArrayLiteralExpression(value)) {
+        if (flattenContext.level < FlattenLevel.ObjectRest && flattenContext.iterationMode === IterationMode.Iterable) {
             // Read the elements of the iterable into an array
             value = ensureIdentifier(
                 flattenContext,