diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 881b25ee532..ea38a8f4b31 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -2078,15 +2078,20 @@ module ts {
                 }
             }
             else {
-                // For an array binding element the specified or inferred type of the parent must be an array-like type
-                if (!isArrayLikeType(parentType)) {
-                    error(pattern, Diagnostics.Type_0_is_not_an_array_type, typeToString(parentType));
-                    return unknownType;
-                }
+                // This elementType will be used if the specific property corresponding to this index is not
+                // present (aka the tuple element property). This call also checks that the parentType is in
+                // fact an iterable or array (depending on target language).
+                let elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false);
                 if (!declaration.dotDotDotToken) {
+                    if (elementType.flags & TypeFlags.Any) {
+                        return elementType;
+                    }
+
                     // Use specific property type when parent is a tuple or numeric index type when parent is an array
                     let propName = "" + indexOf(pattern.elements, declaration);
-                    type = isTupleLikeType(parentType) ? getTypeOfPropertyOfType(parentType, propName) : getIndexTypeOfType(parentType, IndexKind.Number);
+                    type = isTupleLikeType(parentType)
+                        ? getTypeOfPropertyOfType(parentType, propName)
+                        : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
                             error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), (<TupleType>parentType).elementTypes.length, pattern.elements.length);
@@ -2099,7 +2104,7 @@ module ts {
                 }
                 else {
                     // Rest element has an array type with the same element type as the parent type
-                    type = createArrayType(getIndexTypeOfType(parentType, IndexKind.Number));
+                    type = createArrayType(elementType);
                 }
             }
             return type;
@@ -2188,7 +2193,34 @@ module ts {
                     hasSpreadElement = true;
                 }
             });
-            return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes);
+            if (!elementTypes.length) {
+                return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType;
+            }
+            else if (hasSpreadElement) {
+                let unionOfElements = getUnionType(elementTypes);
+                if (languageVersion >= ScriptTarget.ES6) {
+                    // If the user has something like:
+                    //
+                    //     function fun(...[a, ...b]) { }
+                    //
+                    // Normally, in ES6, the implied type of an array binding pattern with a rest element is
+                    // an iterable. However, there is a requirement in our type system that all rest
+                    // parameters be array types. To satisfy this, we have an exception to the rule that
+                    // says the type of an array binding pattern with a rest element is an array type
+                    // if it is *itself* in a rest parameter. It will still be compatible with a spreaded
+                    // iterable argument, but within the function it will be an array.
+                    let parent = pattern.parent;
+                    let isRestParameter = parent.kind === SyntaxKind.Parameter &&
+                        pattern === (<ParameterDeclaration>parent).name &&
+                        (<ParameterDeclaration>parent).dotDotDotToken !== undefined;
+                    return isRestParameter ? createArrayType(unionOfElements) : createIterableType(unionOfElements);
+                }
+
+                return createArrayType(unionOfElements);
+            }
+
+            // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
+            return createTupleType(elementTypes);
         }
 
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
@@ -3461,6 +3493,10 @@ module ts {
             return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol"));
         }
 
+        function createIterableType(elementType: Type): Type {
+            return globalIterableType !== emptyObjectType ? createTypeReference(<GenericType>globalIterableType, [elementType]) : emptyObjectType;
+        }
+
         function createArrayType(elementType: Type): Type {
             // globalArrayType will be undefined if we get here during creation of the Array type. This for example happens if
             // user code augments the Array type with call or construct signatures that have an array type as the return type.
@@ -5600,7 +5636,7 @@ module ts {
                 }
             }
 
-            if (container.kind === SyntaxKind.ComputedPropertyName) {
+            if (container && container.kind === SyntaxKind.ComputedPropertyName) {
                 error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
             }
             else if (isCallExpression) {
@@ -5968,12 +6004,14 @@ module ts {
         }
 
         function checkSpreadElementExpression(node: SpreadElementExpression, contextualMapper?: TypeMapper): Type {
-            let type = checkExpressionCached(node.expression, contextualMapper);
-            if (!isArrayLikeType(type)) {
-                error(node.expression, Diagnostics.Type_0_is_not_an_array_type, typeToString(type));
-                return unknownType;
-            }
-            return type;
+            // It is usually not safe to call checkExpressionCached if we can be contextually typing.
+            // You can tell that we are contextually typing because of the contextualMapper parameter.
+            // While it is true that a spread element can have a contextual type, it does not do anything
+            // with this type. It is neither affected by it, nor does it propagate it to its operand.
+            // So the fact that contextualMapper is passed is not important, because the operand of a spread
+            // element is not contextually typed.
+            let arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper);
+            return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false);
         }
 
         function checkArrayLiteral(node: ArrayLiteralExpression, contextualMapper?: TypeMapper): Type {
@@ -5981,18 +6019,13 @@ module ts {
             if (!elements.length) {
                 return createArrayType(undefinedType);
             }
-            let hasSpreadElement: boolean = false;
+            let hasSpreadElement = false;
             let elementTypes: Type[] = [];
-            forEach(elements, e => {
+            for (let e of elements) {
                 let type = checkExpression(e, contextualMapper);
-                if (e.kind === SyntaxKind.SpreadElementExpression) {
-                    elementTypes.push(getIndexTypeOfType(type, IndexKind.Number) || anyType);
-                    hasSpreadElement = true;
-                }
-                else {
-                    elementTypes.push(type);
-                }
-            });
+                elementTypes.push(type);
+                hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
+            }
             if (!hasSpreadElement) {
                 let contextualType = getContextualType(node);
                 if (contextualType && contextualTypeIsTupleLikeType(contextualType) || isAssignmentTarget(node)) {
@@ -6615,7 +6648,7 @@ module ts {
             for (let i = 0; i < args.length; i++) {
                 let arg = args[i];
                 if (arg.kind !== SyntaxKind.OmittedExpression) {
-                    let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i);
+                    let paramType = getTypeAtPosition(signature, i);
                     let argType: Type;
                     if (i === 0 && args[i].parent.kind === SyntaxKind.TaggedTemplateExpression) {
                         argType = globalTemplateStringsArrayType;
@@ -6638,7 +6671,7 @@ module ts {
                     // No need to check for omitted args and template expressions, their exlusion value is always undefined
                     if (excludeArgument[i] === false) {
                         let arg = args[i];
-                        let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i);
+                        let paramType = getTypeAtPosition(signature, i);
                         inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType);
                     }
                 }
@@ -6671,7 +6704,7 @@ module ts {
                 let arg = args[i];
                 if (arg.kind !== SyntaxKind.OmittedExpression) {
                     // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter)
-                    let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i);
+                    let paramType = getTypeAtPosition(signature, i);
                     // A tagged template expression provides a special first argument, and string literals get string literal types
                     // unless we're reporting errors
                     let argType = i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression ? globalTemplateStringsArrayType :
@@ -7145,14 +7178,9 @@ module ts {
         }
 
         function getTypeAtPosition(signature: Signature, pos: number): Type {
-            if (pos >= 0) {
-                return signature.hasRestParameter ?
-                    pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) :
-                    pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType;
-            }
             return signature.hasRestParameter ?
-                getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]) :
-                anyArrayType;
+                pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) :
+                pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType;
         }
 
         function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) {
@@ -7588,11 +7616,10 @@ module ts {
         }
 
         function checkArrayLiteralAssignment(node: ArrayLiteralExpression, sourceType: Type, contextualMapper?: TypeMapper): Type {
-            // TODOO(andersh): Allow iterable source type in ES6
-            if (!isArrayLikeType(sourceType)) {
-                error(node, Diagnostics.Type_0_is_not_an_array_type, typeToString(sourceType));
-                return sourceType;
-            }
+            // This elementType will be used if the specific property corresponding to this index is not
+            // present (aka the tuple element property). This call also checks that the parentType is in
+            // fact an iterable or array (depending on target language).
+            let elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false);
             let elements = node.elements;
             for (let i = 0; i < elements.length; i++) {
                 let e = elements[i];
@@ -7600,8 +7627,9 @@ module ts {
                     if (e.kind !== SyntaxKind.SpreadElementExpression) {
                         let propName = "" + i;
                         let type = sourceType.flags & TypeFlags.Any ? sourceType :
-                            isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) :
-                                getIndexTypeOfType(sourceType, IndexKind.Number);
+                            isTupleLikeType(sourceType)
+                                ? getTypeOfPropertyOfType(sourceType, propName)
+                                : elementType;
                         if (type) {
                             checkDestructuringAssignment(e, type, contextualMapper);
                         }
@@ -7616,7 +7644,7 @@ module ts {
                     }
                     else {
                         if (i === elements.length - 1) {
-                            checkReferenceAssignment((<SpreadElementExpression>e).expression, sourceType, contextualMapper);
+                            checkReferenceAssignment((<SpreadElementExpression>e).expression, createArrayType(elementType), contextualMapper);
                         }
                         else {
                             error(e, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
@@ -9373,29 +9401,41 @@ module ts {
 
         function checkRightHandSideOfForOf(rhsExpression: Expression): Type {
             let expressionType = getTypeOfExpression(rhsExpression);
-            return languageVersion >= ScriptTarget.ES6
-                ? checkIteratedType(expressionType, rhsExpression)
-                : checkElementTypeOfArrayOrString(expressionType, rhsExpression);
+            return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true);
+        }
+
+        function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean): Type {
+            if (languageVersion >= ScriptTarget.ES6) {
+                return checkIteratedType(inputType, errorNode) || anyType;
+            }
+
+            if (allowStringInput) {
+                return checkElementTypeOfArrayOrString(inputType, errorNode);
+            }
+            
+            if (isArrayLikeType(inputType)) {
+                return getIndexTypeOfType(inputType, IndexKind.Number);
+            }
+
+            error(errorNode, Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType));
+            return unknownType;
         }
 
         /**
-         * When expressionForError is undefined, it means we should not report any errors.
+         * When errorNode is undefined, it means we should not report any errors.
          */
-        function checkIteratedType(iterable: Type, expressionForError: Expression): Type {
+        function checkIteratedType(iterable: Type, errorNode: Node): Type {
             Debug.assert(languageVersion >= ScriptTarget.ES6);
-            let iteratedType = getIteratedType(iterable, expressionForError);
+            let iteratedType = getIteratedType(iterable, errorNode);
             // Now even though we have extracted the iteratedType, we will have to validate that the type
             // passed in is actually an Iterable.
-            if (expressionForError && iteratedType) {
-                let completeIterableType = globalIterableType !== emptyObjectType
-                    ? createTypeReference(<GenericType>globalIterableType, [iteratedType])
-                    : emptyObjectType;
-                checkTypeAssignableTo(iterable, completeIterableType, expressionForError);
+            if (errorNode && iteratedType) {
+                checkTypeAssignableTo(iterable, createIterableType(iteratedType), errorNode);
             }
 
             return iteratedType;
 
-            function getIteratedType(iterable: Type, expressionForError: Expression) {
+            function getIteratedType(iterable: Type, errorNode: Node) {
                 // We want to treat type as an iterable, and get the type it is an iterable of. The iterable
                 // must have the following structure (annotated with the names of the variables below):
                 //
@@ -9426,6 +9466,12 @@ module ts {
                     return undefined;
                 }
 
+                // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable<number>),
+                // then just grab its type argument.
+                if ((iterable.flags & TypeFlags.Reference) && (<GenericType>iterable).target === globalIterableType) {
+                    return (<GenericType>iterable).typeArguments[0];
+                }
+
                 let iteratorFunction = getTypeOfPropertyOfType(iterable, getPropertyNameForKnownSymbolName("iterator"));
                 if (iteratorFunction && allConstituentTypesHaveKind(iteratorFunction, TypeFlags.Any)) {
                     return undefined;
@@ -9433,8 +9479,8 @@ module ts {
 
                 let iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray;
                 if (iteratorFunctionSignatures.length === 0) {
-                    if (expressionForError) {
-                        error(expressionForError, Diagnostics.The_right_hand_side_of_a_for_of_statement_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
+                    if (errorNode) {
+                        error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
                     }
                     return undefined;
                 }
@@ -9451,8 +9497,8 @@ module ts {
 
                 let iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray;
                 if (iteratorNextFunctionSignatures.length === 0) {
-                    if (expressionForError) {
-                        error(expressionForError, Diagnostics.The_iterator_returned_by_the_right_hand_side_of_a_for_of_statement_must_have_a_next_method);
+                    if (errorNode) {
+                        error(errorNode, Diagnostics.An_iterator_must_have_a_next_method);
                     }
                     return undefined;
                 }
@@ -9464,8 +9510,8 @@ module ts {
 
                 let iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
                 if (!iteratorNextValue) {
-                    if (expressionForError) {
-                        error(expressionForError, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
+                    if (errorNode) {
+                        error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
                     }
                     return undefined;
                 }
@@ -9491,7 +9537,7 @@ module ts {
          *   1. Some constituent is neither a string nor an array.
          *   2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable).
          */
-        function checkElementTypeOfArrayOrString(arrayOrStringType: Type, expressionForError: Expression): Type {
+        function checkElementTypeOfArrayOrString(arrayOrStringType: Type, errorNode: Node): Type {
             Debug.assert(languageVersion < ScriptTarget.ES6);
 
             // After we remove all types that are StringLike, we will know if there was a string constituent
@@ -9502,7 +9548,7 @@ module ts {
             let reportedError = false;
             if (hasStringConstituent) {
                 if (languageVersion < ScriptTarget.ES5) {
-                    error(expressionForError, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
+                    error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
                     reportedError = true;
                 }
 
@@ -9522,7 +9568,7 @@ module ts {
                     let diagnostic = hasStringConstituent
                         ? Diagnostics.Type_0_is_not_an_array_type
                         : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type;
-                    error(expressionForError, diagnostic, typeToString(arrayType));
+                    error(errorNode, diagnostic, typeToString(arrayType));
                 }
                 return hasStringConstituent ? stringType : unknownType;
             }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 4b93081dc31..65c711475d6 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -434,7 +434,7 @@ module ts {
         return path.replace(/\\/g, "/");
     }
 
-    // Returns length of path root (i.e. length of "/", "x:/", "//server/share/")
+    // Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files")
     export function getRootLength(path: string): number {
         if (path.charCodeAt(0) === CharacterCodes.slash) {
             if (path.charCodeAt(1) !== CharacterCodes.slash) return 1;
@@ -448,6 +448,8 @@ module ts {
             if (path.charCodeAt(2) === CharacterCodes.slash) return 3;
             return 2;
         }
+        let idx = path.indexOf('://');
+        if (idx !== -1) return idx + 3
         return 0;
     }
 
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index b4380f4d2de..5062be5ed46 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -344,8 +344,8 @@ module ts {
         The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant: { code: 2485, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot be a previously defined constant." },
         The_left_hand_side_of_a_for_in_statement_cannot_be_a_previously_defined_constant: { code: 2486, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a previously defined constant." },
         Invalid_left_hand_side_in_for_of_statement: { code: 2487, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...of' statement." },
-        The_right_hand_side_of_a_for_of_statement_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator." },
-        The_iterator_returned_by_the_right_hand_side_of_a_for_of_statement_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method." },
+        Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "Type must have a '[Symbol.iterator]()' method that returns an iterator." },
+        An_iterator_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "An iterator must have a 'next()' method." },
         The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: { code: 2490, category: DiagnosticCategory.Error, key: "The type returned by the 'next()' method of an iterator must have a 'value' property." },
         The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: { code: 2491, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a destructuring pattern." },
         Cannot_redeclare_identifier_0_in_catch_clause: { code: 2492, category: DiagnosticCategory.Error, key: "Cannot redeclare identifier '{0}' in catch clause" },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index fe349b78343..4476b0cad4a 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1367,11 +1367,11 @@
         "category": "Error",
         "code": 2487
     },
-    "The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator.": {
+    "Type must have a '[Symbol.iterator]()' method that returns an iterator.": {
         "category": "Error",
         "code": 2488
     },
-    "The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method.": {
+    "An iterator must have a 'next()' method.": {
         "category": "Error",
         "code": 2489
     },
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 43db3e69cd7..940edf04191 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1136,8 +1136,8 @@ var __param = this.__param || function(index, decorator) { return function (targ
                         if (!computedPropertyNamesToGeneratedNames) {
                             computedPropertyNamesToGeneratedNames = [];
                         }
-
-                        let generatedName = computedPropertyNamesToGeneratedNames[node.id];
+                        
+                        let generatedName = computedPropertyNamesToGeneratedNames[getNodeId(node)];
                         if (generatedName) {
                             // we have already generated a variable for this node, write that value instead.
                             write(generatedName);
@@ -1145,7 +1145,7 @@ var __param = this.__param || function(index, decorator) { return function (targ
                         }
 
                         generatedName = createAndRecordTempVariable(TempFlags.Auto).text;
-                        computedPropertyNamesToGeneratedNames[node.id] = generatedName;
+                        computedPropertyNamesToGeneratedNames[getNodeId(node)] = generatedName;
                         write(generatedName);
                         write(" = ");
                     }
@@ -1381,211 +1381,163 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 }
             }
 
-            function emitDownlevelObjectLiteralWithComputedProperties(node: ObjectLiteralExpression, firstComputedPropertyIndex: number): void {
-                let parenthesizedObjectLiteral = createDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex);
-                return emit(parenthesizedObjectLiteral);
+            function emitObjectLiteralBody(node: ObjectLiteralExpression, numElements: number): void {
+                if (numElements === 0) {
+                    write("{}");
+                    return;
+                }
+
+                write("{");
+
+                if (numElements > 0) {
+                    var properties = node.properties;
+
+                    // If we are not doing a downlevel transformation for object literals,
+                    // then try to preserve the original shape of the object literal.
+                    // Otherwise just try to preserve the formatting.
+                    if (numElements === properties.length) {
+                        emitLinePreservingList(node, properties, /* allowTrailingComma */ languageVersion >= ScriptTarget.ES5, /* spacesBetweenBraces */ true);
+                    }
+                    else {
+                        let multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
+                        if (!multiLine) {
+                            write(" ");
+                        }
+                        else {
+                            increaseIndent();
+                        }
+
+                        emitList(properties, 0, numElements, /*multiLine*/ multiLine, /*trailingComma*/ false);
+
+                        if (!multiLine) {
+                            write(" ");
+                        }
+                        else {
+                            decreaseIndent();
+                        }
+                    }
+                }
+
+                write("}");
             }
 
-            function createDownlevelObjectLiteralWithComputedProperties(originalObjectLiteral: ObjectLiteralExpression, firstComputedPropertyIndex: number): ParenthesizedExpression {
+            function emitDownlevelObjectLiteralWithComputedProperties(node: ObjectLiteralExpression, firstComputedPropertyIndex: number) {
+                let multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
+                let properties = node.properties;
+
+                write("(");
+
+                if (multiLine) {
+                    increaseIndent();
+                }
+
                 // For computed properties, we need to create a unique handle to the object
                 // literal so we can modify it without risking internal assignments tainting the object.
                 let tempVar = createAndRecordTempVariable(TempFlags.Auto);
 
-                // Hold onto the initial non-computed properties in a new object literal,
-                // then create the rest through property accesses on the temp variable.
-                let initialObjectLiteral = <ObjectLiteralExpression>createSynthesizedNode(SyntaxKind.ObjectLiteralExpression);
-                initialObjectLiteral.properties = <NodeArray<ObjectLiteralElement>>originalObjectLiteral.properties.slice(0, firstComputedPropertyIndex);
-                initialObjectLiteral.flags |= NodeFlags.MultiLine;
+                // Write out the first non-computed properties
+                // (or all properties if none of them are computed),
+                // then emit the rest through indexing on the temp variable.
+                emit(tempVar)
+                write(" = ");
+                emitObjectLiteralBody(node, firstComputedPropertyIndex);
 
-                // The comma expressions that will patch the object literal.
-                // This will end up being something like '_a = { ... }, _a.x = 10, _a.y = 20, _a'.
-                let propertyPatches = createBinaryExpression(tempVar, SyntaxKind.EqualsToken, initialObjectLiteral);
+                for (let i = firstComputedPropertyIndex, n = properties.length; i < n; i++) {
+                    writeComma();
 
-                ts.forEach(originalObjectLiteral.properties, property => {
-                    let patchedProperty = tryCreatePatchingPropertyAssignment(originalObjectLiteral, tempVar, property);
-                    if (patchedProperty) {
-                        // TODO(drosen): Preserve comments
-                        //let leadingComments = getLeadingCommentRanges(currentSourceFile.text, property.pos);
-                        //let trailingComments = getTrailingCommentRanges(currentSourceFile.text, property.end);
-                        //addCommentsToSynthesizedNode(patchedProperty, leadingComments, trailingComments);
+                    let property = properties[i];
 
-                        propertyPatches = createBinaryExpression(propertyPatches, SyntaxKind.CommaToken, patchedProperty);
+                    emitStart(property)
+                    if (property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor) {
+                        // TODO (drosen): Reconcile with 'emitMemberFunctions'.
+                        let accessors = getAllAccessorDeclarations(node.properties, <AccessorDeclaration>property);
+                        if (property !== accessors.firstAccessor) {
+                            continue;
+                        }
+                        write("Object.defineProperty(");
+                        emit(tempVar);
+                        write(", ");
+                        emitStart(node.name);
+                        emitExpressionForPropertyName(property.name);
+                        emitEnd(property.name);
+                        write(", {");
+                        increaseIndent();
+                        if (accessors.getAccessor) {
+                            writeLine()
+                            emitLeadingComments(accessors.getAccessor);
+                            write("get: ");
+                            emitStart(accessors.getAccessor);
+                            write("function ");
+                            emitSignatureAndBody(accessors.getAccessor);
+                            emitEnd(accessors.getAccessor);
+                            emitTrailingComments(accessors.getAccessor);
+                            write(",");
+                        }
+                        if (accessors.setAccessor) {
+                            writeLine();
+                            emitLeadingComments(accessors.setAccessor);
+                            write("set: ");
+                            emitStart(accessors.setAccessor);
+                            write("function ");
+                            emitSignatureAndBody(accessors.setAccessor);
+                            emitEnd(accessors.setAccessor);
+                            emitTrailingComments(accessors.setAccessor);
+                            write(",");
+                        }
+                        writeLine();
+                        write("enumerable: true,");
+                        writeLine();
+                        write("configurable: true");
+                        decreaseIndent();
+                        writeLine();
+                        write("})");
+                        emitEnd(property);
                     }
-                });
+                    else {
+                        emitLeadingComments(property);
+                        emitStart(property.name);
+                        emit(tempVar);
+                        emitMemberAccessForPropertyName(property.name);
+                        emitEnd(property.name);
 
-                // Finally, return the temp variable.
-                propertyPatches = createBinaryExpression(propertyPatches, SyntaxKind.CommaToken, createIdentifier(tempVar.text, /*startsOnNewLine:*/ true));
+                        write(" = ");
 
-                let result = createParenthesizedExpression(propertyPatches);
-                
-                // TODO(drosen): Preserve comments
-                // let leadingComments = getLeadingCommentRanges(currentSourceFile.text, originalObjectLiteral.pos);
-                // let trailingComments = getTrailingCommentRanges(currentSourceFile.text, originalObjectLiteral.end);
-                //addCommentsToSynthesizedNode(result, leadingComments, trailingComments);
-
-                return result;
-            }
-
-            function addCommentsToSynthesizedNode(node: SynthesizedNode, leadingCommentRanges: CommentRange[], trailingCommentRanges: CommentRange[]): void {
-                node.leadingCommentRanges = leadingCommentRanges;
-                node.trailingCommentRanges = trailingCommentRanges;
-            }
-
-            // Returns 'undefined' if a property has already been accounted for
-            // (e.g. a 'get' accessor which has already been emitted along with its 'set' accessor).
-            function tryCreatePatchingPropertyAssignment(objectLiteral: ObjectLiteralExpression, tempVar: Identifier, property: ObjectLiteralElement): Expression {
-                let leftHandSide = createMemberAccessForPropertyName(tempVar, property.name);
-                let maybeRightHandSide = tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral, property);
-
-                return maybeRightHandSide && createBinaryExpression(leftHandSide, SyntaxKind.EqualsToken, maybeRightHandSide, /*startsOnNewLine:*/ true);
-            }
-
-            function tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral: ObjectLiteralExpression, property: ObjectLiteralElement) {
-                switch (property.kind) {
-                    case SyntaxKind.PropertyAssignment:
-                        return (<PropertyAssignment>property).initializer;
-
-                    case SyntaxKind.ShorthandPropertyAssignment:
-                        // TODO: (andersh) Technically it isn't correct to make an identifier here since getExpressionNamePrefix returns
-                        // a string containing a dotted name. In general I'm not a fan of mini tree rewriters as this one, elsewhere we
-                        // manage by just emitting strings (which is a lot more performant).
-                        //let prefix = createIdentifier(resolver.getExpressionNamePrefix((<ShorthandPropertyAssignment>property).name));
-                        //return createPropertyAccessExpression(prefix, (<ShorthandPropertyAssignment>property).name);
-                        return createIdentifier(resolver.getExpressionNameSubstitution((<ShorthandPropertyAssignment>property).name, getGeneratedNameForNode));
-
-                    case SyntaxKind.MethodDeclaration:
-                        return createFunctionExpression((<MethodDeclaration>property).parameters, (<MethodDeclaration>property).body);
-
-                    case SyntaxKind.GetAccessor:
-                    case SyntaxKind.SetAccessor:
-                        let { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(objectLiteral.properties, <AccessorDeclaration>property);
-
-                        // Only emit the first accessor.
-                        if (firstAccessor !== property) {
-                            return undefined;
+                        if (property.kind === SyntaxKind.PropertyAssignment) {
+                            emit((<PropertyAssignment>property).initializer);
                         }
-
-                        let propertyDescriptor = <ObjectLiteralExpression>createSynthesizedNode(SyntaxKind.ObjectLiteralExpression);
-
-                        let descriptorProperties = <NodeArray<ObjectLiteralElement>>[];
-                        if (getAccessor) {
-                            let getProperty = createPropertyAssignment(createIdentifier("get"), createFunctionExpression(getAccessor.parameters, getAccessor.body));
-                            descriptorProperties.push(getProperty);
+                        else if (property.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                            emitExpressionIdentifier((<ShorthandPropertyAssignment>property).name);
                         }
-                        if (setAccessor) {
-                            let setProperty = createPropertyAssignment(createIdentifier("set"), createFunctionExpression(setAccessor.parameters, setAccessor.body));
-                            descriptorProperties.push(setProperty);
+                        else if (property.kind === SyntaxKind.MethodDeclaration) {
+                            emitFunctionDeclaration(<MethodDeclaration>property);
                         }
+                        else {
+                            Debug.fail("ObjectLiteralElement type not accounted for: " + property.kind);
+                        }
+                    }
 
-                        let trueExpr = <PrimaryExpression>createSynthesizedNode(SyntaxKind.TrueKeyword);
-
-                        let enumerableTrue = createPropertyAssignment(createIdentifier("enumerable"), trueExpr);
-                        descriptorProperties.push(enumerableTrue);
-
-                        let configurableTrue = createPropertyAssignment(createIdentifier("configurable"), trueExpr);
-                        descriptorProperties.push(configurableTrue);
-
-                        propertyDescriptor.properties = descriptorProperties;
-
-                        let objectDotDefineProperty = createPropertyAccessExpression(createIdentifier("Object"), createIdentifier("defineProperty"));
-                        return createCallExpression(objectDotDefineProperty, createNodeArray(propertyDescriptor));
-
-                    default:
-                        Debug.fail(`ObjectLiteralElement kind ${property.kind} not accounted for.`);
+                    emitEnd(property);
                 }
-            }
 
-            function createParenthesizedExpression(expression: Expression) {
-                let result = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);
-                result.expression = expression;
+                writeComma();
+                emit(tempVar);
 
-                return result;
-            }
-
-            function createNodeArray<T extends Node>(...elements: T[]): NodeArray<T> {
-                let result = <NodeArray<T>>elements;
-                result.pos = -1;
-                result.end = -1;
-
-                return result;
-            }
-
-            function createBinaryExpression(left: Expression, operator: SyntaxKind, right: Expression, startsOnNewLine?: boolean): BinaryExpression {
-                let result = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression, startsOnNewLine);
-                result.operatorToken = createSynthesizedNode(operator);
-                result.left = left;
-                result.right = right;
-
-                return result;
-            }
-
-            function createExpressionStatement(expression: Expression): ExpressionStatement {
-                let result = <ExpressionStatement>createSynthesizedNode(SyntaxKind.ExpressionStatement);
-                result.expression = expression;
-                return result;
-            }
-
-            function createMemberAccessForPropertyName(expression: LeftHandSideExpression, memberName: DeclarationName): PropertyAccessExpression | ElementAccessExpression {
-                if (memberName.kind === SyntaxKind.Identifier) {
-                    return createPropertyAccessExpression(expression, <Identifier>memberName);
+                if (multiLine) {
+                    decreaseIndent();
+                    writeLine();
                 }
-                else if (memberName.kind === SyntaxKind.StringLiteral || memberName.kind === SyntaxKind.NumericLiteral) {
-                    return createElementAccessExpression(expression, <LiteralExpression>memberName);
+
+                write(")");
+
+                function writeComma() {
+                    if (multiLine) {
+                        write(",");
+                        writeLine();
+                    }
+                    else {
+                        write(", ");
+                    }
                 }
-                else if (memberName.kind === SyntaxKind.ComputedPropertyName) {
-                    return createElementAccessExpression(expression, (<ComputedPropertyName>memberName).expression);
-                }
-                else {
-                    Debug.fail(`Kind '${memberName.kind}' not accounted for.`);
-                }
-            }
-
-            function createPropertyAssignment(name: LiteralExpression | Identifier, initializer: Expression) {
-                let result = <PropertyAssignment>createSynthesizedNode(SyntaxKind.PropertyAssignment);
-                result.name = name;
-                result.initializer = initializer;
-
-                return result;
-            }
-
-            function createFunctionExpression(parameters: NodeArray<ParameterDeclaration>, body: Block): FunctionExpression {
-                let result = <FunctionExpression>createSynthesizedNode(SyntaxKind.FunctionExpression);
-                result.parameters = parameters;
-                result.body = body;
-
-                return result;
-            }
-
-            function createPropertyAccessExpression(expression: LeftHandSideExpression, name: Identifier): PropertyAccessExpression {
-                let result = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
-                result.expression = expression;
-                result.dotToken = createSynthesizedNode(SyntaxKind.DotToken);
-                result.name = name;
-
-                return result;
-            }
-
-            function createElementAccessExpression(expression: LeftHandSideExpression, argumentExpression: Expression): ElementAccessExpression {
-                let result = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
-                result.expression = expression;
-                result.argumentExpression = argumentExpression;
-
-                return result;
-            }
-
-            function createIdentifier(name: string, startsOnNewLine?: boolean) {
-                let result = <Identifier>createSynthesizedNode(SyntaxKind.Identifier, startsOnNewLine);
-                result.text = name;
-
-                return result;
-            }
-
-            function createCallExpression(invokedExpression: MemberExpression, arguments: NodeArray<Expression>) {
-                let result = <CallExpression>createSynthesizedNode(SyntaxKind.CallExpression);
-                result.expression = invokedExpression;
-                result.arguments = arguments;
-
-                return result;
             }
 
             function emitObjectLiteral(node: ObjectLiteralExpression): void {
@@ -1613,13 +1565,33 @@ var __param = this.__param || function(index, decorator) { return function (targ
 
                 // Ordinary case: either the object has no computed properties
                 // or we're compiling with an ES6+ target.
-                write("{");
+                emitObjectLiteralBody(node, properties.length);
+            }
 
-                if (properties.length) {
-                    emitLinePreservingList(node, properties, /*allowTrailingComma:*/ languageVersion >= ScriptTarget.ES5, /*spacesBetweenBraces:*/ true)
-                }
+            function createBinaryExpression(left: Expression, operator: SyntaxKind, right: Expression, startsOnNewLine?: boolean): BinaryExpression {
+                let result = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression, startsOnNewLine);
+                result.operatorToken = createSynthesizedNode(operator);
+                result.left = left;
+                result.right = right;
 
-                write("}");
+                return result;
+            }
+
+            function createPropertyAccessExpression(expression: LeftHandSideExpression, name: Identifier): PropertyAccessExpression {
+                let result = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
+                result.expression = expression;
+                result.dotToken = createSynthesizedNode(SyntaxKind.DotToken);
+                result.name = name;
+
+                return result;
+             }
+
+            function createElementAccessExpression(expression: LeftHandSideExpression, argumentExpression: Expression): ElementAccessExpression {
+                let result = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
+                result.expression = expression;
+                result.argumentExpression = argumentExpression;
+
+                return result;
             }
 
             function emitComputedPropertyName(node: ComputedPropertyName) {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 7e1a840560f..6d89fb6cc83 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -526,6 +526,19 @@ module ts {
                     // the *body* of the container.
                     node = node.parent;
                     break;
+                case SyntaxKind.Decorator:
+                    // Decorators are always applied outside of the body of a class or method. 
+                    if (node.parent.kind === SyntaxKind.Parameter && isClassElement(node.parent.parent)) {
+                        // If the decorator's parent is a Parameter, we resolve the this container from
+                        // the grandparent class declaration.
+                        node = node.parent.parent;
+                    }
+                    else if (isClassElement(node.parent)) {
+                        // If the decorator's parent is a class element, we resolve the 'this' container
+                        // from the parent class declaration.
+                        node = node.parent;
+                    }
+                    break;
                 case SyntaxKind.ArrowFunction:
                     if (!includeArrowFunctions) {
                         continue;
@@ -568,6 +581,19 @@ module ts {
                     // the *body* of the container.
                     node = node.parent;
                     break;
+                case SyntaxKind.Decorator:
+                    // Decorators are always applied outside of the body of a class or method. 
+                    if (node.parent.kind === SyntaxKind.Parameter && isClassElement(node.parent.parent)) {
+                        // If the decorator's parent is a Parameter, we resolve the this container from
+                        // the grandparent class declaration.
+                        node = node.parent.parent;
+                    }
+                    else if (isClassElement(node.parent)) {
+                        // If the decorator's parent is a class element, we resolve the 'this' container
+                        // from the parent class declaration.
+                        node = node.parent;
+                    }
+                    break;
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
@@ -921,6 +947,7 @@ module ts {
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.SetAccessor:
+            case SyntaxKind.MethodSignature:
             case SyntaxKind.IndexSignature:
                 return true;
             default:
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index a83c04e6e86..4c50e0e0cad 100644
--- a/src/harness/typeWriter.ts
+++ b/src/harness/typeWriter.ts
@@ -52,6 +52,7 @@ class TypeWriterWalker {
             case ts.SyntaxKind.PostfixUnaryExpression:
             case ts.SyntaxKind.BinaryExpression:
             case ts.SyntaxKind.ConditionalExpression:
+            case ts.SyntaxKind.SpreadElementExpression:
                 this.log(node, this.getTypeOfNode(node));
                 break;
 
diff --git a/src/server/client.ts b/src/server/client.ts
index d395d2a832c..3306bd5a9d4 100644
--- a/src/server/client.ts
+++ b/src/server/client.ts
@@ -104,7 +104,7 @@ module ts.server {
                 var response: T = JSON.parse(responseBody);
             }
             catch (e) {
-                throw new Error("Malformed response: Failed to parse server response: " + lastMessage + ". \r\n  Error detailes: " + e.message);
+                throw new Error("Malformed response: Failed to parse server response: " + lastMessage + ". \r\n  Error details: " + e.message);
             }
 
             // verify the sequence numbers
@@ -446,6 +446,7 @@ module ts.server {
             if (!response.body) {
                 return undefined;
             }
+
             var helpItems: protocol.SignatureHelpItems = response.body;
             var span = helpItems.applicableSpan;
             var start = this.lineOffsetToPosition(fileName, span.start);
@@ -465,7 +466,26 @@ module ts.server {
         }
 
         getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
-            throw new Error("Not Implemented Yet.");
+            var lineOffset = this.positionToOneBasedLineOffset(fileName, position);
+            var args: protocol.FileLocationRequestArgs = {
+                file: fileName,
+                line: lineOffset.line,
+                offset: lineOffset.offset,
+            };
+
+            var request = this.processRequest<protocol.OccurrencesRequest>(CommandNames.Occurrences, args);
+            var response = this.processResponse<protocol.OccurrencesResponse>(request);
+
+            return response.body.map(entry => {
+                var fileName = entry.file;
+                var start = this.lineOffsetToPosition(fileName, entry.start);
+                var end = this.lineOffsetToPosition(fileName, entry.end);
+                return {
+                    fileName,
+                    textSpan: ts.createTextSpanFromBounds(start, end),
+                    isWriteAccess: entry.isWriteAccess,
+                };
+            });
         }
 
         getOutliningSpans(fileName: string): OutliningSpan[] {
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 366e4dbfd84..8b4ab2cffa8 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -458,7 +458,7 @@ module ts.server {
                 var info = this.filenameToScriptInfo[args.file];
                 if (info) {
                     info.setFormatOptions(args.formatOptions);  
-                    this.log("Host configuration update for file " + args.file);
+                    this.log("Host configuration update for file " + args.file, "Info");
                 }
             }
             else {
@@ -823,7 +823,6 @@ module ts.server {
          */
 
         closeClientFile(filename: string) {
-            // TODO: tsconfig check
             var info = ts.lookUp(this.filenameToScriptInfo, filename);
             if (info) {
                 this.closeOpenFile(info);
@@ -856,6 +855,9 @@ module ts.server {
         }
 
         printProjects() {
+            if (!this.psLogger.isVerbose()) {
+                return;
+            }
             this.psLogger.startGroup();
             for (var i = 0, len = this.inferredProjects.length; i < len; i++) {
                 var project = this.inferredProjects[i];
diff --git a/src/server/protocol.d.ts b/src/server/protocol.d.ts
index 3a03c22d49e..5bc1ffbe4dc 100644
--- a/src/server/protocol.d.ts
+++ b/src/server/protocol.d.ts
@@ -165,6 +165,25 @@ declare module ts.server.protocol {
         body?: FileSpan[];
     }
 
+    /**
+      * Get occurrences request; value of command field is
+      * "occurrences". Return response giving spans that are relevant
+      * in the file at a given line and column.
+      */
+    export interface OccurrencesRequest extends FileLocationRequest {
+    }
+
+    export interface OccurrencesResponseItem extends FileSpan {
+        /**
+          * True if the occurrence is a write location, false otherwise.
+          */
+        isWriteAccess: boolean;
+    }
+
+    export interface OccurrencesResponse extends Response {
+        body?: OccurrencesResponseItem[];
+    }
+
     /**
       * Find references request; value of command field is
       * "references". Return response giving the file locations that
@@ -405,6 +424,13 @@ declare module ts.server.protocol {
         arguments: OpenRequestArgs;
     }
 
+    /**
+      *  Exit request; value of command field is "exit".  Ask the server process
+      *  to exit.
+      */
+    export interface ExitRequest extends Request {
+    }
+
     /**
       * Close request; value of command field is "close". Notify the
       * server that the client has closed a previously open file.  If
diff --git a/src/server/server.ts b/src/server/server.ts
index 4c13be80c4c..828deca2b2d 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -177,6 +177,12 @@ module ts.server {
             super(host, logger);
         }
 
+        exit() {
+            this.projectService.log("Exiting...","Info");
+            this.projectService.closeLog();
+            process.exit(0);
+        }
+
         listen() {
             rl.on('line',(input: string) => {
                 var message = input.trim();
@@ -184,9 +190,7 @@ module ts.server {
             });
 
             rl.on('close',() => {
-                this.projectService.log("Exiting...");
-                this.projectService.closeLog();
-                process.exit(0);
+                this.exit();
             });
         }
     }
diff --git a/src/server/session.ts b/src/server/session.ts
index 80831e69284..09373d6bf96 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -76,25 +76,27 @@ module ts.server {
     }
 
     export module CommandNames {
+        export var Brace = "brace";
         export var Change = "change";
         export var Close = "close";
         export var Completions = "completions";
         export var CompletionDetails = "completionEntryDetails";
-        export var SignatureHelp = "signatureHelp";        
         export var Configure = "configure";
         export var Definition = "definition";
+        export var Exit = "exit";
         export var Format = "format";
         export var Formatonkey = "formatonkey";
         export var Geterr = "geterr";
         export var NavBar = "navbar";
         export var Navto = "navto";
+        export var Occurrences = "occurrences";
         export var Open = "open";
         export var Quickinfo = "quickinfo";
         export var References = "references";
         export var Reload = "reload";
         export var Rename = "rename";
         export var Saveto = "saveto";
-        export var Brace = "brace";
+        export var SignatureHelp = "signatureHelp";        
         export var Unknown = "unknown";
     }
 
@@ -116,7 +118,7 @@ module ts.server {
 
         constructor(private host: ServerHost, private logger: Logger) {
             this.projectService =
-                new ProjectService(host, logger, (eventName,project,fileName) => {
+            new ProjectService(host, logger, (eventName, project, fileName) => {
                 this.handleEvent(eventName, project, fileName);
             });
         }
@@ -261,7 +263,7 @@ module ts.server {
             }
         }
 
-        getDefinition(line: number, offset: number, fileName: string): protocol.FileSpan[] {
+        getDefinition({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.FileSpan[] {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -283,7 +285,37 @@ module ts.server {
             }));
         }
 
-        getRenameLocations(line: number, offset: number, fileName: string,findInComments: boolean, findInStrings: boolean): protocol.RenameResponseBody {
+        getOccurrences({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.OccurrencesResponseItem[] {
+            fileName = ts.normalizePath(fileName);
+            let project = this.projectService.getProjectForFile(fileName);
+
+            if (!project) {
+                throw Errors.NoProject;
+            }
+
+            let { compilerService } = project;
+            let position = compilerService.host.lineOffsetToPosition(fileName, line, offset);
+
+            let occurrences = compilerService.languageService.getOccurrencesAtPosition(fileName, position);
+
+            if (!occurrences) {
+                return undefined;
+            }
+
+            return occurrences.map(occurrence => {
+                let { fileName, isWriteAccess, textSpan } = occurrence;
+                let start = compilerService.host.positionToLineOffset(fileName, textSpan.start);
+                let end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));
+                return {
+                    start,
+                    end,
+                    file: fileName,
+                    isWriteAccess
+                }
+            });
+        }
+
+        getRenameLocations({line, offset, file: fileName, findInComments, findInStrings }: protocol.RenameRequestArgs): protocol.RenameResponseBody {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -351,7 +383,7 @@ module ts.server {
             return { info: renameInfo, locs: bakedRenameLocs };
         }
 
-        getReferences(line: number, offset: number, fileName: string): protocol.ReferencesResponseBody {
+        getReferences({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.ReferencesResponseBody {
             // TODO: get all projects for this file; report refs for all projects deleting duplicates
             // can avoid duplicates by eliminating same ref file from subsequent projects
             var file = ts.normalizePath(fileName);
@@ -377,7 +409,7 @@ module ts.server {
             var nameSpan = nameInfo.textSpan;
             var nameColStart = compilerService.host.positionToLineOffset(file, nameSpan.start).offset;
             var nameText = compilerService.host.getScriptSnapshot(file).getText(nameSpan.start, ts.textSpanEnd(nameSpan));
-            var bakedRefs: protocol.ReferencesResponseItem[] = references.map((ref) => {
+            var bakedRefs: protocol.ReferencesResponseItem[] = references.map(ref => {
                 var start = compilerService.host.positionToLineOffset(ref.fileName, ref.textSpan.start);
                 var refLineSpan = compilerService.host.lineToTextSpan(ref.fileName, start.line - 1);
                 var snap = compilerService.host.getScriptSnapshot(ref.fileName);
@@ -398,12 +430,12 @@ module ts.server {
             };
         }
 
-        openClientFile(fileName: string) {
+        openClientFile({ file: fileName }: protocol.OpenRequestArgs) {
             var file = ts.normalizePath(fileName);
             this.projectService.openClientFile(file);
         }
 
-        getQuickInfo(line: number, offset: number, fileName: string): protocol.QuickInfoResponseBody {
+        getQuickInfo({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.QuickInfoResponseBody {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -429,7 +461,7 @@ module ts.server {
             };
         }
 
-        getFormattingEditsForRange(line: number, offset: number, endLine: number, endOffset: number, fileName: string): protocol.CodeEdit[] {
+        getFormattingEditsForRange({line, offset, endLine, endOffset, file: fileName}: protocol.FormatRequestArgs): protocol.CodeEdit[] {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -456,7 +488,7 @@ module ts.server {
             });
         }
 
-        getFormattingEditsAfterKeystroke(line: number, offset: number, key: string, fileName: string): protocol.CodeEdit[] {
+        getFormattingEditsAfterKeystroke({line, offset, key, file: fileName}: protocol.FormatOnKeyRequestArgs): protocol.CodeEdit[] {
             var file = ts.normalizePath(fileName);
 
             var project = this.projectService.getProjectForFile(file);
@@ -529,7 +561,7 @@ module ts.server {
             });
         }
 
-        getCompletions(line: number, offset: number, prefix: string, fileName: string): protocol.CompletionEntry[] {
+        getCompletions({ line, offset, prefix, file: fileName}: protocol.CompletionsRequestArgs): protocol.CompletionEntry[] {
             if (!prefix) {
                 prefix = "";
             }
@@ -555,8 +587,7 @@ module ts.server {
             }, []).sort((a, b) => a.name.localeCompare(b.name));
         }
 
-        getCompletionEntryDetails(line: number, offset: number,
-            entryNames: string[], fileName: string): protocol.CompletionEntryDetails[] {
+        getCompletionEntryDetails({ line, offset, entryNames, file: fileName}: protocol.CompletionDetailsRequestArgs): protocol.CompletionEntryDetails[] {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -575,20 +606,20 @@ module ts.server {
             }, []);
         }
 
-        getSignatureHelpItems(line: number, offset: number, fileName: string): protocol.SignatureHelpItems {
+        getSignatureHelpItems({ line, offset, file: fileName }: protocol.SignatureHelpRequestArgs): protocol.SignatureHelpItems {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
                 throw Errors.NoProject;
             }
-            
+
             var compilerService = project.compilerService;
             var position = compilerService.host.lineOffsetToPosition(file, line, offset);
             var helpItems = compilerService.languageService.getSignatureHelpItems(file, position);
             if (!helpItems) {
                 return undefined;
             }
-            
+
             var span = helpItems.applicableSpan;
             var result: protocol.SignatureHelpItems = {
                 items: helpItems.items,
@@ -600,11 +631,11 @@ module ts.server {
                 argumentIndex: helpItems.argumentIndex,
                 argumentCount: helpItems.argumentCount,
             }
-            
+
             return result;
         }
-                
-        getDiagnostics(delay: number, fileNames: string[]) {
+
+        getDiagnostics({ delay, files: fileNames }: protocol.GeterrRequestArgs): void {
             var checkList = fileNames.reduce((accum: PendingErrorCheck[], fileName: string) => {
                 fileName = ts.normalizePath(fileName);
                 var project = this.projectService.getProjectForFile(fileName);
@@ -615,11 +646,11 @@ module ts.server {
             }, []);
 
             if (checkList.length > 0) {
-                this.updateErrorCheck(checkList, this.changeSeq,(n) => n == this.changeSeq, delay)
+                this.updateErrorCheck(checkList, this.changeSeq, (n) => n == this.changeSeq, delay)
             }
         }
 
-        change(line: number, offset: number, endLine: number, endOffset: number, insertString: string, fileName: string) {
+        change({ line, offset, endLine, endOffset, insertString, file: fileName }: protocol.ChangeRequestArgs): void {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (project) {
@@ -634,7 +665,7 @@ module ts.server {
             }
         }
 
-        reload(fileName: string, tempFileName: string, reqSeq = 0) {
+        reload({ file: fileName, tmpfile: tempFileName }: protocol.ReloadRequestArgs, reqSeq = 0): void {
             var file = ts.normalizePath(fileName);
             var tmpfile = ts.normalizePath(tempFileName);
             var project = this.projectService.getProjectForFile(file);
@@ -647,7 +678,7 @@ module ts.server {
             }
         }
 
-        saveToTmp(fileName: string, tempFileName: string) {
+        saveToTmp({ file: fileName, tmpfile: tempFileName }: protocol.SavetoRequestArgs): void {
             var file = ts.normalizePath(fileName);
             var tmpfile = ts.normalizePath(tempFileName);
 
@@ -657,7 +688,7 @@ module ts.server {
             }
         }
 
-        closeClientFile(fileName: string) {
+        closeClientFile({ file: fileName }: protocol.FileRequestArgs) {
             var file = ts.normalizePath(fileName);
             this.projectService.closeClientFile(file);
         }
@@ -681,7 +712,7 @@ module ts.server {
             }));
         }
 
-        getNavigationBarItems(fileName: string): protocol.NavigationBarItem[] {
+        getNavigationBarItems({ file: fileName }: protocol.FileRequestArgs): protocol.NavigationBarItem[]{
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -697,7 +728,7 @@ module ts.server {
             return this.decorateNavigationBarItem(project, fileName, items);
         }
 
-        getNavigateToItems(searchValue: string, fileName: string, maxResultCount?: number): protocol.NavtoItem[] {
+        getNavigateToItems({ searchValue, file: fileName, maxResultCount }: protocol.NavtoRequestArgs): protocol.NavtoItem[]{
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -736,7 +767,7 @@ module ts.server {
             });
         }
 
-        getBraceMatching(line: number, offset: number, fileName: string): protocol.TextSpan[] {
+        getBraceMatching({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.TextSpan[]{
             var file = ts.normalizePath(fileName);
             
             var project = this.projectService.getProjectForFile(file);
@@ -758,6 +789,9 @@ module ts.server {
             }));
         }
 
+        exit() {
+        }
+
         onMessage(message: string) {
             if (this.logger.isVerbose()) {
                 this.logger.info("request: " + message);
@@ -769,110 +803,97 @@ module ts.server {
                 var errorMessage: string;
                 var responseRequired = true;
                 switch (request.command) {
+                    case CommandNames.Exit: {
+                        this.exit();
+                        responseRequired = false;
+                        break;
+                    }
                     case CommandNames.Definition: { 
-                        var defArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getDefinition(defArgs.line, defArgs.offset, defArgs.file);
+                        response = this.getDefinition(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.References: { 
-                        var refArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getReferences(refArgs.line, refArgs.offset, refArgs.file);
+                        response = this.getReferences(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Rename: {
-                        var renameArgs = <protocol.RenameRequestArgs>request.arguments;
-                        response = this.getRenameLocations(renameArgs.line, renameArgs.offset, renameArgs.file, renameArgs.findInComments, renameArgs.findInStrings);
+                        response = this.getRenameLocations(<protocol.RenameRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Open: {
-                        var openArgs = <protocol.OpenRequestArgs>request.arguments;
-                        this.openClientFile(openArgs.file);
+                        this.openClientFile(<protocol.OpenRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Quickinfo: {
-                        var quickinfoArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getQuickInfo(quickinfoArgs.line, quickinfoArgs.offset, quickinfoArgs.file);
+                        response = this.getQuickInfo(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Format: {
-                        var formatArgs = <protocol.FormatRequestArgs>request.arguments;
-                        response = this.getFormattingEditsForRange(formatArgs.line, formatArgs.offset, formatArgs.endLine, formatArgs.endOffset, formatArgs.file);
+                        response = this.getFormattingEditsForRange(<protocol.FormatRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Formatonkey: {
-                        var formatOnKeyArgs = <protocol.FormatOnKeyRequestArgs>request.arguments;
-                        response = this.getFormattingEditsAfterKeystroke(formatOnKeyArgs.line, formatOnKeyArgs.offset, formatOnKeyArgs.key, formatOnKeyArgs.file);
+                        response = this.getFormattingEditsAfterKeystroke(<protocol.FormatOnKeyRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Completions: {
-                        var completionsArgs = <protocol.CompletionsRequestArgs>request.arguments;
-                        response = this.getCompletions(completionsArgs.line, completionsArgs.offset, completionsArgs.prefix, completionsArgs.file);
+                        response = this.getCompletions(<protocol.CompletionsRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.CompletionDetails: {
-                        var completionDetailsArgs = <protocol.CompletionDetailsRequestArgs>request.arguments;
-                        response =
-                            this.getCompletionEntryDetails(completionDetailsArgs.line,completionDetailsArgs.offset,
-                                                           completionDetailsArgs.entryNames,completionDetailsArgs.file);
+                        response = this.getCompletionEntryDetails(<protocol.CompletionDetailsRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.SignatureHelp: {
-                        var signatureHelpArgs = <protocol.SignatureHelpRequestArgs>request.arguments;
-                        response = this.getSignatureHelpItems(signatureHelpArgs.line, signatureHelpArgs.offset, signatureHelpArgs.file);
+                        response = this.getSignatureHelpItems(<protocol.SignatureHelpRequestArgs>request.arguments);
                         break;
                     }    
                     case CommandNames.Geterr: {
-                        var geterrArgs = <protocol.GeterrRequestArgs>request.arguments;
-                        response = this.getDiagnostics(geterrArgs.delay, geterrArgs.files);
+                        this.getDiagnostics(<protocol.GeterrRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Change: {
-                        var changeArgs = <protocol.ChangeRequestArgs>request.arguments;
-                        this.change(changeArgs.line, changeArgs.offset, changeArgs.endLine, changeArgs.endOffset,
-                                    changeArgs.insertString, changeArgs.file);
+                        this.change(<protocol.ChangeRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Configure: {
-                        var configureArgs = <protocol.ConfigureRequestArguments>request.arguments;
-                        this.projectService.setHostConfiguration(configureArgs);
+                        this.projectService.setHostConfiguration(<protocol.ConfigureRequestArguments>request.arguments);
                         this.output(undefined, CommandNames.Configure, request.seq);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Reload: {
-                        var reloadArgs = <protocol.ReloadRequestArgs>request.arguments;
-                        this.reload(reloadArgs.file, reloadArgs.tmpfile, request.seq);
+                        this.reload(<protocol.ReloadRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Saveto: {
-                        var savetoArgs = <protocol.SavetoRequestArgs>request.arguments;
-                        this.saveToTmp(savetoArgs.file, savetoArgs.tmpfile);
+                        this.saveToTmp(<protocol.SavetoRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Close: {
-                        var closeArgs = <protocol.FileRequestArgs>request.arguments;
-                        this.closeClientFile(closeArgs.file);
+                        this.closeClientFile(<protocol.FileRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Navto: {
-                        var navtoArgs = <protocol.NavtoRequestArgs>request.arguments;
-                        response = this.getNavigateToItems(navtoArgs.searchValue, navtoArgs.file, navtoArgs.maxResultCount);
+                        response = this.getNavigateToItems(<protocol.NavtoRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Brace: {
-                        var braceArguments = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getBraceMatching(braceArguments.line, braceArguments.offset, braceArguments.file);
+                        response = this.getBraceMatching(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.NavBar: {
-                        var navBarArgs = <protocol.FileRequestArgs>request.arguments;
-                        response = this.getNavigationBarItems(navBarArgs.file);
+                        response = this.getNavigationBarItems(<protocol.FileRequestArgs>request.arguments);
+                        break;
+                    }
+                    case CommandNames.Occurrences: {
+                        response = this.getOccurrences(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     default: {
diff --git a/tests/baselines/reference/ES5For-of30.errors.txt b/tests/baselines/reference/ES5For-of30.errors.txt
index 0b02a55ba3f..e99b8284bf3 100644
--- a/tests/baselines/reference/ES5For-of30.errors.txt
+++ b/tests/baselines/reference/ES5For-of30.errors.txt
@@ -1,12 +1,18 @@
 tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,6): error TS2461: Type 'string | number' is not an array type.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,7): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error TS2322: Type 'string' is not assignable to type 'number'.
 
 
-==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (1 errors) ====
+==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (3 errors) ====
     var a: string, b: number;
     var tuple: [number, string] = [2, "3"];
     for ([a = 1, b = ""] of tuple) {
          ~~~~~~~~~~~~~~~
 !!! error TS2461: Type 'string | number' is not an array type.
+          ~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+                 ~
+!!! error TS2322: Type 'string' is not assignable to type 'number'.
         a;
         b;
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5SymbolProperty1.js b/tests/baselines/reference/ES5SymbolProperty1.js
index ab3f420c95c..1073a33163d 100644
--- a/tests/baselines/reference/ES5SymbolProperty1.js
+++ b/tests/baselines/reference/ES5SymbolProperty1.js
@@ -14,6 +14,7 @@ obj[Symbol.foo];
 var Symbol;
 var obj = (_a = {},
     _a[Symbol.foo] = 0,
-    _a);
+    _a
+);
 obj[Symbol.foo];
 var _a;
diff --git a/tests/baselines/reference/FunctionDeclaration8_es6.js b/tests/baselines/reference/FunctionDeclaration8_es6.js
index 62692997a91..64f6bff50c0 100644
--- a/tests/baselines/reference/FunctionDeclaration8_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration8_es6.js
@@ -2,7 +2,5 @@
 var v = { [yield]: foo }
 
 //// [FunctionDeclaration8_es6.js]
-var v = (_a = {},
-    _a[yield] = foo,
-    _a);
+var v = (_a = {}, _a[yield] = foo, _a);
 var _a;
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.js b/tests/baselines/reference/FunctionDeclaration9_es6.js
index c63cf5bb458..bca309d2d62 100644
--- a/tests/baselines/reference/FunctionDeclaration9_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.js
@@ -5,8 +5,6 @@ function * foo() {
 
 //// [FunctionDeclaration9_es6.js]
 function foo() {
-    var v = (_a = {},
-        _a[] = foo,
-        _a);
+    var v = (_a = {}, _a[] = foo, _a);
     var _a;
 }
diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.js b/tests/baselines/reference/FunctionPropertyAssignments5_es6.js
index 51e5d0000e4..188a843f751 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.js
@@ -2,7 +2,5 @@
 var v = { *[foo()]() { } }
 
 //// [FunctionPropertyAssignments5_es6.js]
-var v = (_a = {},
-    _a[foo()] = function () { },
-    _a);
+var v = (_a = {}, _a[foo()] = function () { }, _a);
 var _a;
diff --git a/tests/baselines/reference/arrayLiteralSpread.types b/tests/baselines/reference/arrayLiteralSpread.types
index 0dae59521bf..73d4f6013ed 100644
--- a/tests/baselines/reference/arrayLiteralSpread.types
+++ b/tests/baselines/reference/arrayLiteralSpread.types
@@ -9,44 +9,55 @@ function f0() {
     var a1 = [...a];
 >a1 : number[]
 >[...a] : number[]
+>...a : number
 >a : number[]
 
     var a2 = [1, ...a];
 >a2 : number[]
 >[1, ...a] : number[]
+>...a : number
 >a : number[]
 
     var a3 = [1, 2, ...a];
 >a3 : number[]
 >[1, 2, ...a] : number[]
+>...a : number
 >a : number[]
 
     var a4 = [...a, 1];
 >a4 : number[]
 >[...a, 1] : number[]
+>...a : number
 >a : number[]
 
     var a5 = [...a, 1, 2];
 >a5 : number[]
 >[...a, 1, 2] : number[]
+>...a : number
 >a : number[]
 
     var a6 = [1, 2, ...a, 1, 2];
 >a6 : number[]
 >[1, 2, ...a, 1, 2] : number[]
+>...a : number
 >a : number[]
 
     var a7 = [1, ...a, 2, ...a];
 >a7 : number[]
 >[1, ...a, 2, ...a] : number[]
+>...a : number
 >a : number[]
+>...a : number
 >a : number[]
 
     var a8 = [...a, ...a, ...a];
 >a8 : number[]
 >[...a, ...a, ...a] : number[]
+>...a : number
 >a : number[]
+>...a : number
 >a : number[]
+>...a : number
 >a : number[]
 }
 
@@ -60,6 +71,7 @@ function f1() {
     var b = ["hello", ...a, true];
 >b : (string | number | boolean)[]
 >["hello", ...a, true] : (string | number | boolean)[]
+>...a : number
 >a : number[]
 
     var b: (string | number | boolean)[];
@@ -72,19 +84,29 @@ function f2() {
     var a = [...[...[...[...[...[]]]]]];
 >a : any[]
 >[...[...[...[...[...[]]]]]] : undefined[]
+>...[...[...[...[...[]]]]] : undefined
 >[...[...[...[...[]]]]] : undefined[]
+>...[...[...[...[]]]] : undefined
 >[...[...[...[]]]] : undefined[]
+>...[...[...[]]] : undefined
 >[...[...[]]] : undefined[]
+>...[...[]] : undefined
 >[...[]] : undefined[]
+>...[] : undefined
 >[] : undefined[]
 
     var b = [...[...[...[...[...[5]]]]]];
 >b : number[]
 >[...[...[...[...[...[5]]]]]] : number[]
+>...[...[...[...[...[5]]]]] : number
 >[...[...[...[...[5]]]]] : number[]
+>...[...[...[...[5]]]] : number
 >[...[...[...[5]]]] : number[]
+>...[...[...[5]]] : number
 >[...[...[5]]] : number[]
+>...[...[5]] : number
 >[...[5]] : number[]
+>...[5] : number
 >[5] : number[]
 }
 
diff --git a/tests/baselines/reference/callWithSpreadES6.types b/tests/baselines/reference/callWithSpreadES6.types
index 8a75d21e4ef..10dd611d213 100644
--- a/tests/baselines/reference/callWithSpreadES6.types
+++ b/tests/baselines/reference/callWithSpreadES6.types
@@ -38,11 +38,13 @@ foo(1, 2, "abc");
 foo(1, 2, ...a);
 >foo(1, 2, ...a) : void
 >foo : (x: number, y: number, ...z: string[]) => void
+>...a : string
 >a : string[]
 
 foo(1, 2, ...a, "abc");
 >foo(1, 2, ...a, "abc") : void
 >foo : (x: number, y: number, ...z: string[]) => void
+>...a : string
 >a : string[]
 
 obj.foo(1, 2, "abc");
@@ -56,6 +58,7 @@ obj.foo(1, 2, ...a);
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 obj.foo(1, 2, ...a, "abc");
@@ -63,6 +66,7 @@ obj.foo(1, 2, ...a, "abc");
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 (obj.foo)(1, 2, "abc");
@@ -78,6 +82,7 @@ obj.foo(1, 2, ...a, "abc");
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 (obj.foo)(1, 2, ...a, "abc");
@@ -86,6 +91,7 @@ obj.foo(1, 2, ...a, "abc");
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 xa[1].foo(1, 2, "abc");
@@ -101,6 +107,7 @@ xa[1].foo(1, 2, ...a);
 >xa[1] : X
 >xa : X[]
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 xa[1].foo(1, 2, ...a, "abc");
@@ -109,6 +116,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >xa[1] : X
 >xa : X[]
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
@@ -120,6 +128,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >xa[1] : X
 >xa : X[]
 >foo : (x: number, y: number, ...z: string[]) => any
+>...[1, 2, "abc"] : string | number
 >[1, 2, "abc"] : (string | number)[]
 
 class C {
@@ -145,6 +154,7 @@ class C {
 >foo : (x: number, y: number, ...z: string[]) => void
 >x : number
 >y : number
+>...z : string
 >z : string[]
     }
     foo(x: number, y: number, ...z: string[]) {
@@ -167,6 +177,7 @@ class D extends C {
         super(1, 2, ...a);
 >super(1, 2, ...a) : void
 >super : typeof C
+>...a : string
 >a : string[]
     }
     foo() {
@@ -183,6 +194,7 @@ class D extends C {
 >super.foo : (x: number, y: number, ...z: string[]) => void
 >super : C
 >foo : (x: number, y: number, ...z: string[]) => void
+>...a : string
 >a : string[]
     }
 }
@@ -192,5 +204,6 @@ var c = new C(1, 2, ...a);
 >c : C
 >new C(1, 2, ...a) : C
 >C : typeof C
+>...a : string
 >a : string[]
 
diff --git a/tests/baselines/reference/computedPropertyNames10_ES5.js b/tests/baselines/reference/computedPropertyNames10_ES5.js
index 302f9355be8..14d9235b12b 100644
--- a/tests/baselines/reference/computedPropertyNames10_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames10_ES5.js
@@ -32,5 +32,6 @@ var v = (_a = {},
     _a[true] = function () { },
     _a["hello bye"] = function () { },
     _a["hello " + a + " bye"] = function () { },
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames11_ES5.js b/tests/baselines/reference/computedPropertyNames11_ES5.js
index 69902003342..64c0b0bd67e 100644
--- a/tests/baselines/reference/computedPropertyNames11_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames11_ES5.js
@@ -21,16 +21,61 @@ var s;
 var n;
 var a;
 var v = (_a = {},
-    _a[s] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[n] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[s + s] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[s + n] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[+s] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[""] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[0] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[a] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[true] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a["hello bye"] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a["hello " + a + " bye"] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a);
+    Object.defineProperty(_a, s, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, n, {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, s + s, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, s + n, {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, +s, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "", {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 0, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, a, {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, true, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "hello bye", {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "hello " + a + " bye", {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames18_ES5.js b/tests/baselines/reference/computedPropertyNames18_ES5.js
index a62af506531..b65c7fd4f7d 100644
--- a/tests/baselines/reference/computedPropertyNames18_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames18_ES5.js
@@ -9,6 +9,7 @@ function foo() {
 function foo() {
     var obj = (_a = {},
         _a[this.bar] = 0,
-        _a);
+        _a
+    );
     var _a;
 }
diff --git a/tests/baselines/reference/computedPropertyNames19_ES5.js b/tests/baselines/reference/computedPropertyNames19_ES5.js
index bda3e01bbed..36f3e66c7c2 100644
--- a/tests/baselines/reference/computedPropertyNames19_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames19_ES5.js
@@ -10,6 +10,7 @@ var M;
 (function (M) {
     var obj = (_a = {},
         _a[this.bar] = 0,
-        _a);
+        _a
+    );
     var _a;
 })(M || (M = {}));
diff --git a/tests/baselines/reference/computedPropertyNames1_ES5.js b/tests/baselines/reference/computedPropertyNames1_ES5.js
index 37e06616c2f..4fdec28c7aa 100644
--- a/tests/baselines/reference/computedPropertyNames1_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames1_ES5.js
@@ -6,7 +6,17 @@ var v = {
 
 //// [computedPropertyNames1_ES5.js]
 var v = (_a = {},
-    _a[0 + 1] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[0 + 1] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a);
+    Object.defineProperty(_a, 0 + 1, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 0 + 1, {
+        set: function (v) { } //No error
+        ,
+        enumerable: true,
+        configurable: true
+    }),
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames20_ES5.js b/tests/baselines/reference/computedPropertyNames20_ES5.js
index 1eec0a7bcdb..65acd7fa08f 100644
--- a/tests/baselines/reference/computedPropertyNames20_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames20_ES5.js
@@ -6,5 +6,6 @@ var obj = {
 //// [computedPropertyNames20_ES5.js]
 var obj = (_a = {},
     _a[this.bar] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames22_ES5.js b/tests/baselines/reference/computedPropertyNames22_ES5.js
index df12193250b..e82bf673b52 100644
--- a/tests/baselines/reference/computedPropertyNames22_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames22_ES5.js
@@ -15,7 +15,8 @@ var C = (function () {
     C.prototype.bar = function () {
         var obj = (_a = {},
             _a[this.bar()] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };
diff --git a/tests/baselines/reference/computedPropertyNames23_ES5.js b/tests/baselines/reference/computedPropertyNames23_ES5.js
index 8f68d9f3102..8e42a29f7e7 100644
--- a/tests/baselines/reference/computedPropertyNames23_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames23_ES5.js
@@ -15,9 +15,7 @@ var C = (function () {
     C.prototype.bar = function () {
         return 0;
     };
-    C.prototype[(_a = {},
-        _a[this.bar()] = 1,
-        _a)[0]] = function () { };
+    C.prototype[(_a = {}, _a[this.bar()] = 1, _a)[0]] = function () { };
     return C;
     var _a;
 })();
diff --git a/tests/baselines/reference/computedPropertyNames25_ES5.js b/tests/baselines/reference/computedPropertyNames25_ES5.js
index f8196dd1307..b6a8d254b26 100644
--- a/tests/baselines/reference/computedPropertyNames25_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames25_ES5.js
@@ -36,7 +36,8 @@ var C = (function (_super) {
     C.prototype.foo = function () {
         var obj = (_a = {},
             _a[_super.prototype.bar.call(this)] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };
diff --git a/tests/baselines/reference/computedPropertyNames26_ES5.js b/tests/baselines/reference/computedPropertyNames26_ES5.js
index 884d5c0f664..7a0a982eb41 100644
--- a/tests/baselines/reference/computedPropertyNames26_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames26_ES5.js
@@ -30,9 +30,7 @@ var C = (function (_super) {
     function C() {
         _super.apply(this, arguments);
     }
-    C.prototype[(_a = {},
-        _a[_super.bar.call(this)] = 1,
-        _a)[0]] = function () { };
+    C.prototype[(_a = {}, _a[_super.bar.call(this)] = 1, _a)[0]] = function () { };
     return C;
     var _a;
 })(Base);
diff --git a/tests/baselines/reference/computedPropertyNames28_ES5.js b/tests/baselines/reference/computedPropertyNames28_ES5.js
index b88cb0dfaf9..5940c498db8 100644
--- a/tests/baselines/reference/computedPropertyNames28_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames28_ES5.js
@@ -28,7 +28,8 @@ var C = (function (_super) {
         _super.call(this);
         var obj = (_a = {},
             _a[(_super.call(this), "prop")] = function () { },
-            _a);
+            _a
+        );
         var _a;
     }
     return C;
diff --git a/tests/baselines/reference/computedPropertyNames29_ES5.js b/tests/baselines/reference/computedPropertyNames29_ES5.js
index 022c930ab67..4682ae9105e 100644
--- a/tests/baselines/reference/computedPropertyNames29_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames29_ES5.js
@@ -19,7 +19,8 @@ var C = (function () {
         (function () {
             var obj = (_a = {},
                 _a[_this.bar()] = function () { },
-                _a);
+                _a
+            );
             var _a;
         });
         return 0;
diff --git a/tests/baselines/reference/computedPropertyNames30_ES5.js b/tests/baselines/reference/computedPropertyNames30_ES5.js
index fd63a192d07..05196e23c5b 100644
--- a/tests/baselines/reference/computedPropertyNames30_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames30_ES5.js
@@ -33,8 +33,12 @@ var C = (function (_super) {
         _super.call(this);
         (function () {
             var obj = (_a = {},
+                // Ideally, we would capture this. But the reference is
+                // illegal, and not capturing this is consistent with
+                //treatment of other similar violations.
                 _a[(_super.call(this), "prop")] = function () { },
-                _a);
+                _a
+            );
             var _a;
         });
     }
diff --git a/tests/baselines/reference/computedPropertyNames31_ES5.js b/tests/baselines/reference/computedPropertyNames31_ES5.js
index 8a3c1a3f6c5..173e3c7222b 100644
--- a/tests/baselines/reference/computedPropertyNames31_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames31_ES5.js
@@ -40,7 +40,8 @@ var C = (function (_super) {
         (function () {
             var obj = (_a = {},
                 _a[_super.prototype.bar.call(_this)] = function () { },
-                _a);
+                _a
+            );
             var _a;
         });
         return 0;
diff --git a/tests/baselines/reference/computedPropertyNames33_ES5.js b/tests/baselines/reference/computedPropertyNames33_ES5.js
index 3d7c70a9256..38029893bb1 100644
--- a/tests/baselines/reference/computedPropertyNames33_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames33_ES5.js
@@ -17,7 +17,8 @@ var C = (function () {
     C.prototype.bar = function () {
         var obj = (_a = {},
             _a[foo()] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };
diff --git a/tests/baselines/reference/computedPropertyNames34_ES5.js b/tests/baselines/reference/computedPropertyNames34_ES5.js
index fd46b144fa5..4e5790c53b1 100644
--- a/tests/baselines/reference/computedPropertyNames34_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames34_ES5.js
@@ -17,7 +17,8 @@ var C = (function () {
     C.bar = function () {
         var obj = (_a = {},
             _a[foo()] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };
diff --git a/tests/baselines/reference/computedPropertyNames46_ES5.js b/tests/baselines/reference/computedPropertyNames46_ES5.js
index 815f5769f3b..307dadcbe91 100644
--- a/tests/baselines/reference/computedPropertyNames46_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames46_ES5.js
@@ -6,5 +6,6 @@ var o = {
 //// [computedPropertyNames46_ES5.js]
 var o = (_a = {},
     _a["" || 0] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames47_ES5.js b/tests/baselines/reference/computedPropertyNames47_ES5.js
index a2fff2110b4..d03b614b29b 100644
--- a/tests/baselines/reference/computedPropertyNames47_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames47_ES5.js
@@ -16,5 +16,6 @@ var E2;
 })(E2 || (E2 = {}));
 var o = (_a = {},
     _a[E1.x || E2.x] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames48_ES5.js b/tests/baselines/reference/computedPropertyNames48_ES5.js
index 55b08ef8301..15123a98f30 100644
--- a/tests/baselines/reference/computedPropertyNames48_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames48_ES5.js
@@ -25,11 +25,14 @@ var E;
 var a;
 extractIndexer((_a = {},
     _a[a] = "",
-    _a)); // Should return string
+    _a
+)); // Should return string
 extractIndexer((_b = {},
     _b[E.x] = "",
-    _b)); // Should return string
+    _b
+)); // Should return string
 extractIndexer((_c = {},
     _c["" || 0] = "",
-    _c)); // Should return any (widened form of undefined)
+    _c
+)); // Should return any (widened form of undefined)
 var _a, _b, _c;
diff --git a/tests/baselines/reference/computedPropertyNames49_ES5.js b/tests/baselines/reference/computedPropertyNames49_ES5.js
index 5f952c6f3f1..3427ea665a0 100644
--- a/tests/baselines/reference/computedPropertyNames49_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames49_ES5.js
@@ -27,24 +27,41 @@ var x = {
 
 //// [computedPropertyNames49_ES5.js]
 var x = (_a = {
-    p1: 10
-},
-    _a.p1 = 10,
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        p1: 10
+    },
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             return 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ set: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        set: function () {
             // just throw
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a.foo = Object.defineProperty({ get: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "foo", {
+        get: function () {
             if (1 == 1) {
                 return 10;
             }
-        }, enumerable: true, configurable: true }),
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    ,
     _a.p2 = 20,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames4_ES5.js b/tests/baselines/reference/computedPropertyNames4_ES5.js
index ac0fa8ec937..f91476c79c1 100644
--- a/tests/baselines/reference/computedPropertyNames4_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames4_ES5.js
@@ -32,5 +32,6 @@ var v = (_a = {},
     _a[true] = 0,
     _a["hello bye"] = 0,
     _a["hello " + a + " bye"] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames50_ES5.js b/tests/baselines/reference/computedPropertyNames50_ES5.js
index 32502d80e0a..a74561295be 100644
--- a/tests/baselines/reference/computedPropertyNames50_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames50_ES5.js
@@ -27,29 +27,37 @@ var x = {
 
 //// [computedPropertyNames50_ES5.js]
 var x = (_a = {
-    p1: 10,
-    get foo() {
-        if (1 == 1) {
-            return 10;
-        }
-    }
-},
-    _a.p1 = 10,
-    _a.foo = Object.defineProperty({ get: function () {
+        p1: 10,
+        get foo() {
             if (1 == 1) {
                 return 10;
             }
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        }
+    },
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ set: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        set: function () {
             // just throw
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             return 10;
-        }, enumerable: true, configurable: true }),
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    ,
     _a.p2 = 20,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames5_ES5.js b/tests/baselines/reference/computedPropertyNames5_ES5.js
index 3367faa2c20..58c5af2efa3 100644
--- a/tests/baselines/reference/computedPropertyNames5_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames5_ES5.js
@@ -18,5 +18,6 @@ var v = (_a = {},
     _a[{}] = 0,
     _a[undefined] = undefined,
     _a[null] = null,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames6_ES5.js b/tests/baselines/reference/computedPropertyNames6_ES5.js
index 29d035bfcbf..7e9c6202940 100644
--- a/tests/baselines/reference/computedPropertyNames6_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames6_ES5.js
@@ -16,5 +16,6 @@ var v = (_a = {},
     _a[p1] = 0,
     _a[p2] = 1,
     _a[p3] = 2,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames7_ES5.js b/tests/baselines/reference/computedPropertyNames7_ES5.js
index 01cf2efc030..3311ec7e092 100644
--- a/tests/baselines/reference/computedPropertyNames7_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames7_ES5.js
@@ -13,5 +13,6 @@ var E;
 })(E || (E = {}));
 var v = (_a = {},
     _a[E.member] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNames8_ES5.js b/tests/baselines/reference/computedPropertyNames8_ES5.js
index 82d262c7e4e..6eceee81adb 100644
--- a/tests/baselines/reference/computedPropertyNames8_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames8_ES5.js
@@ -15,6 +15,7 @@ function f() {
     var v = (_a = {},
         _a[t] = 0,
         _a[u] = 1,
-        _a);
+        _a
+    );
     var _a;
 }
diff --git a/tests/baselines/reference/computedPropertyNames9_ES5.js b/tests/baselines/reference/computedPropertyNames9_ES5.js
index b1ac6c9e3b6..6c1d7bcb4d0 100644
--- a/tests/baselines/reference/computedPropertyNames9_ES5.js
+++ b/tests/baselines/reference/computedPropertyNames9_ES5.js
@@ -16,5 +16,6 @@ var v = (_a = {},
     _a[f("")] = 0,
     _a[f(0)] = 0,
     _a[f(true)] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType10_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType10_ES5.js
index d8a33951d4a..1f7a3ae123e 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType10_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType10_ES5.js
@@ -12,5 +12,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = "",
     _a[+"bar"] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.js
index 1ee88351154..c4bfde03531 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.js
@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a["" + 0] = function (y) { return y.length; },
     _a["" + 1] = function (y) { return y.length; },
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.js
index 6be09e4bef3..945475f8533 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.js
@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = function (y) { return y.length; },
     _a[+"bar"] = function (y) { return y.length; },
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.js
index b510cda2916..98042f201e3 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.js
@@ -12,5 +12,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = function (y) { return y.length; },
     _a[+"bar"] = function (y) { return y.length; },
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.js
index 0c319a526f4..b17f91be38b 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType4_ES5.js
@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a["" + "foo"] = "",
     _a["" + "bar"] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.js
index 51d78be59d4..c7a728e5ef8 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType5_ES5.js
@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = "",
     _a[+"bar"] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.js
index f50231e3f0f..c97b7c5b1f8 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType6_ES5.js
@@ -15,13 +15,12 @@ foo({
 
 //// [computedPropertyNamesContextualType6_ES5.js]
 foo((_a = {
-    p: "",
-    0: function () { }
-},
-    _a.p = "",
-    _a[0] = function () { },
+        p: "",
+        0: function () { }
+    },
     _a["hi" + "bye"] = true,
     _a[0 + 1] = 0,
     _a[+"hi"] = [0],
-    _a));
+    _a
+));
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.js
index e1c567c62d9..9ca7e826aa7 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType7_ES5.js
@@ -15,13 +15,12 @@ foo({
 
 //// [computedPropertyNamesContextualType7_ES5.js]
 foo((_a = {
-    p: "",
-    0: function () { }
-},
-    _a.p = "",
-    _a[0] = function () { },
+        p: "",
+        0: function () { }
+    },
     _a["hi" + "bye"] = true,
     _a[0 + 1] = 0,
     _a[+"hi"] = [0],
-    _a));
+    _a
+));
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType8_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType8_ES5.js
index 24f6218864c..419ea906550 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType8_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType8_ES5.js
@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a["" + "foo"] = "",
     _a["" + "bar"] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType9_ES5.js b/tests/baselines/reference/computedPropertyNamesContextualType9_ES5.js
index 340802da2af..d3beb8b8deb 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType9_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesContextualType9_ES5.js
@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = "",
     _a[+"bar"] = 0,
-    _a);
+    _a
+);
 var _a;
diff --git a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.js b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.js
index 58c3133e6ee..e77eb79dc70 100644
--- a/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesDeclarationEmit5_ES5.js
@@ -10,9 +10,18 @@ var v = {
 var v = (_a = {},
     _a["" + ""] = 0,
     _a["" + ""] = function () { },
-    _a["" + ""] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a["" + ""] = Object.defineProperty({ set: function (x) { }, enumerable: true, configurable: true }),
-    _a);
+    Object.defineProperty(_a, "" + "", {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "" + "", {
+        set: function (x) { },
+        enumerable: true,
+        configurable: true
+    }),
+    _a
+);
 var _a;
 
 
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js
index 972aaf9b52f..39e393c46cc 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js
@@ -10,6 +10,7 @@ var v = (_a = {},
     _a["hello"] = function () {
         debugger;
     },
-    _a);
+    _a
+);
 var _a;
 //# sourceMappingURL=computedPropertyNamesSourceMap2_ES5.js.map
\ No newline at end of file
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js.map b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js.map
index 413c98fa456..d36428a0379 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js.map
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.js.map
@@ -1,2 +1,2 @@
 //// [computedPropertyNamesSourceMap2_ES5.js.map]
-{"version":3,"file":"computedPropertyNamesSourceMap2_ES5.js","sourceRoot":"","sources":["computedPropertyNamesSourceMap2_ES5.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG;OACH,OAAO;QACJ,QAAQ,CAAC;IACb,CAAC;OACJ,CAAA"}
\ No newline at end of file
+{"version":3,"file":"computedPropertyNamesSourceMap2_ES5.js","sourceRoot":"","sources":["computedPropertyNamesSourceMap2_ES5.ts"],"names":["[\"hello\"]"],"mappings":"AAAA,IAAI,CAAC,GAAG;IACJ,GAAC,OAAO,CAAC;QACLA,QAAQA,CAACA;IACbA,CAACA;;CACJ,CAAA"}
\ No newline at end of file
diff --git a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.sourcemap.txt b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.sourcemap.txt
index 03eec606718..74d69f566a0 100644
--- a/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.sourcemap.txt
+++ b/tests/baselines/reference/computedPropertyNamesSourceMap2_ES5.sourcemap.txt
@@ -24,45 +24,53 @@ sourceFile:computedPropertyNamesSourceMap2_ES5.ts
 4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0)
 ---
 >>>    _a["hello"] = function () {
-1->^^^^^^^
-2 >       ^^^^^^^
-3 >              ^^^^->
+1->^^^^
+2 >    ^^^
+3 >       ^^^^^^^
+4 >              ^
+5 >               ^^^->
 1->{
-  >    [
-2 >       "hello"
-1->Emitted(2, 8) Source(2, 6) + SourceIndex(0)
-2 >Emitted(2, 15) Source(2, 13) + SourceIndex(0)
+  >    
+2 >    [
+3 >       "hello"
+4 >              ]
+1->Emitted(2, 5) Source(2, 5) + SourceIndex(0)
+2 >Emitted(2, 8) Source(2, 6) + SourceIndex(0)
+3 >Emitted(2, 15) Source(2, 13) + SourceIndex(0)
+4 >Emitted(2, 16) Source(2, 14) + SourceIndex(0)
 ---
 >>>        debugger;
 1->^^^^^^^^
 2 >        ^^^^^^^^
 3 >                ^
-1->]() {
+1->() {
   >        
 2 >        debugger
 3 >                ;
-1->Emitted(3, 9) Source(3, 9) + SourceIndex(0)
-2 >Emitted(3, 17) Source(3, 17) + SourceIndex(0)
-3 >Emitted(3, 18) Source(3, 18) + SourceIndex(0)
+1->Emitted(3, 9) Source(3, 9) + SourceIndex(0) name (["hello"])
+2 >Emitted(3, 17) Source(3, 17) + SourceIndex(0) name (["hello"])
+3 >Emitted(3, 18) Source(3, 18) + SourceIndex(0) name (["hello"])
 ---
 >>>    },
 1 >^^^^
 2 >    ^
-3 >     ^^^^->
+3 >     ^^->
 1 >
   >    
 2 >    }
-1 >Emitted(4, 5) Source(4, 5) + SourceIndex(0)
-2 >Emitted(4, 6) Source(4, 6) + SourceIndex(0)
+1 >Emitted(4, 5) Source(4, 5) + SourceIndex(0) name (["hello"])
+2 >Emitted(4, 6) Source(4, 6) + SourceIndex(0) name (["hello"])
 ---
->>>    _a);
-1->^^^^^^^
-2 >       ^
+>>>    _a
+>>>);
+1->^
+2 > ^
+3 >  ^^^^^^->
 1->
   >}
-2 >       
-1->Emitted(5, 8) Source(5, 2) + SourceIndex(0)
-2 >Emitted(5, 9) Source(5, 2) + SourceIndex(0)
+2 > 
+1->Emitted(6, 2) Source(5, 2) + SourceIndex(0)
+2 >Emitted(6, 3) Source(5, 2) + SourceIndex(0)
 ---
 >>>var _a;
 >>>//# sourceMappingURL=computedPropertyNamesSourceMap2_ES5.js.map
\ No newline at end of file
diff --git a/tests/baselines/reference/decoratorOnClassMethod11.errors.txt b/tests/baselines/reference/decoratorOnClassMethod11.errors.txt
new file mode 100644
index 00000000000..5e56c0b62a8
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassMethod11.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts(5,10): error TS2331: 'this' cannot be referenced in a module body.
+
+
+==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts (1 errors) ====
+    module M {
+        class C {
+            decorator(target: Object, key: string): void { }
+    
+            @this.decorator
+             ~~~~
+!!! error TS2331: 'this' cannot be referenced in a module body.
+            method() { }
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/decoratorOnClassMethod11.js b/tests/baselines/reference/decoratorOnClassMethod11.js
new file mode 100644
index 00000000000..71d4298f02c
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassMethod11.js
@@ -0,0 +1,32 @@
+//// [decoratorOnClassMethod11.ts]
+module M {
+    class C {
+        decorator(target: Object, key: string): void { }
+
+        @this.decorator
+        method() { }
+    }
+}
+
+//// [decoratorOnClassMethod11.js]
+var __decorate = this.__decorate || (typeof Reflect === "object" && Reflect.decorate) || function (decorators, target, key, desc) {
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
+var M;
+(function (M) {
+    var C = (function () {
+        function C() {
+        }
+        C.prototype.decorator = function (target, key) { };
+        C.prototype.method = function () { };
+        Object.defineProperty(C.prototype, "method",
+            __decorate([
+                this.decorator
+            ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method")));
+        return C;
+    })();
+})(M || (M = {}));
diff --git a/tests/baselines/reference/decoratorOnClassMethod12.errors.txt b/tests/baselines/reference/decoratorOnClassMethod12.errors.txt
new file mode 100644
index 00000000000..14845839089
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassMethod12.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class
+
+
+==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts (1 errors) ====
+    module M {
+        class S {
+            decorator(target: Object, key: string): void { }
+        }
+        class C extends S {
+            @super.decorator
+             ~~~~~
+!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class
+            method() { }
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/decoratorOnClassMethod12.js b/tests/baselines/reference/decoratorOnClassMethod12.js
new file mode 100644
index 00000000000..7f23947929c
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassMethod12.js
@@ -0,0 +1,46 @@
+//// [decoratorOnClassMethod12.ts]
+module M {
+    class S {
+        decorator(target: Object, key: string): void { }
+    }
+    class C extends S {
+        @super.decorator
+        method() { }
+    }
+}
+
+//// [decoratorOnClassMethod12.js]
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var __decorate = this.__decorate || (typeof Reflect === "object" && Reflect.decorate) || function (decorators, target, key, desc) {
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
+var M;
+(function (M) {
+    var S = (function () {
+        function S() {
+        }
+        S.prototype.decorator = function (target, key) { };
+        return S;
+    })();
+    var C = (function (_super) {
+        __extends(C, _super);
+        function C() {
+            _super.apply(this, arguments);
+        }
+        C.prototype.method = function () { };
+        Object.defineProperty(C.prototype, "method",
+            __decorate([
+                _super.decorator
+            ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method")));
+        return C;
+    })(S);
+})(M || (M = {}));
diff --git a/tests/baselines/reference/decoratorOnClassMethod13.js b/tests/baselines/reference/decoratorOnClassMethod13.js
new file mode 100644
index 00000000000..4321bbb0156
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassMethod13.js
@@ -0,0 +1,29 @@
+//// [decoratorOnClassMethod13.ts]
+declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+
+class C {
+    @dec ["1"]() { }
+    @dec ["b"]() { }
+}
+
+//// [decoratorOnClassMethod13.js]
+var __decorate = this.__decorate || (typeof Reflect === "object" && Reflect.decorate) || function (decorators, target, key, desc) {
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
+class C {
+    [_a = "1"]() { }
+    [_b = "b"]() { }
+}
+Object.defineProperty(C.prototype, _a,
+    __decorate([
+        dec
+    ], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a)));
+Object.defineProperty(C.prototype, _b,
+    __decorate([
+        dec
+    ], C.prototype, _b, Object.getOwnPropertyDescriptor(C.prototype, _b)));
+var _a, _b;
diff --git a/tests/baselines/reference/decoratorOnClassMethod13.types b/tests/baselines/reference/decoratorOnClassMethod13.types
new file mode 100644
index 00000000000..8c34805792f
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassMethod13.types
@@ -0,0 +1,21 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts ===
+declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+>dec : () => <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
+>T : T
+>target : any
+>propertyKey : string
+>descriptor : TypedPropertyDescriptor<T>
+>TypedPropertyDescriptor : TypedPropertyDescriptor<T>
+>T : T
+>TypedPropertyDescriptor : TypedPropertyDescriptor<T>
+>T : T
+
+class C {
+>C : C
+
+    @dec ["1"]() { }
+>dec : unknown
+
+    @dec ["b"]() { }
+>dec : unknown
+}
diff --git a/tests/baselines/reference/for-of14.errors.txt b/tests/baselines/reference/for-of14.errors.txt
index 5e8223381c7..ab95d042689 100644
--- a/tests/baselines/reference/for-of14.errors.txt
+++ b/tests/baselines/reference/for-of14.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/for-ofStatements/for-of14.ts(2,11): error TS2488: The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator.
+tests/cases/conformance/es6/for-ofStatements/for-of14.ts(2,11): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== tests/cases/conformance/es6/for-ofStatements/for-of14.ts (1 errors) ====
     var v: string;
     for (v of new StringIterator) { } // Should fail because the iterator is not iterable
               ~~~~~~~~~~~~~~~~~~
-!!! error TS2488: The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator.
+!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
     
     class StringIterator {
         next() {
diff --git a/tests/baselines/reference/for-of16.errors.txt b/tests/baselines/reference/for-of16.errors.txt
index e3ecca1a256..20e3e876537 100644
--- a/tests/baselines/reference/for-of16.errors.txt
+++ b/tests/baselines/reference/for-of16.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/for-ofStatements/for-of16.ts(2,11): error TS2489: The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method.
+tests/cases/conformance/es6/for-ofStatements/for-of16.ts(2,11): error TS2489: An iterator must have a 'next()' method.
 
 
 ==== tests/cases/conformance/es6/for-ofStatements/for-of16.ts (1 errors) ====
     var v: string;
     for (v of new StringIterator) { } // Should fail
               ~~~~~~~~~~~~~~~~~~
-!!! error TS2489: The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method.
+!!! error TS2489: An iterator must have a 'next()' method.
     
     class StringIterator {
         [Symbol.iterator]() {
diff --git a/tests/baselines/reference/for-of57.js b/tests/baselines/reference/for-of57.js
new file mode 100644
index 00000000000..5a867c332f7
--- /dev/null
+++ b/tests/baselines/reference/for-of57.js
@@ -0,0 +1,7 @@
+//// [for-of57.ts]
+var iter: Iterable<number>;
+for (let num of iter) { }
+
+//// [for-of57.js]
+var iter;
+for (let num of iter) { }
diff --git a/tests/baselines/reference/for-of57.types b/tests/baselines/reference/for-of57.types
new file mode 100644
index 00000000000..cfd4f68cfca
--- /dev/null
+++ b/tests/baselines/reference/for-of57.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/for-ofStatements/for-of57.ts ===
+var iter: Iterable<number>;
+>iter : Iterable<number>
+>Iterable : Iterable<T>
+
+for (let num of iter) { }
+>num : number
+>iter : Iterable<number>
+
diff --git a/tests/baselines/reference/iterableArrayPattern1.js b/tests/baselines/reference/iterableArrayPattern1.js
new file mode 100644
index 00000000000..b45ac92d1fd
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern1.js
@@ -0,0 +1,28 @@
+//// [iterableArrayPattern1.ts]
+var [a, b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern1.js]
+var [a, b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern1.types b/tests/baselines/reference/iterableArrayPattern1.types
new file mode 100644
index 00000000000..8be8521c684
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern1.types
@@ -0,0 +1,36 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts ===
+var [a, b] = new SymbolIterator;
+>a : symbol
+>b : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern10.errors.txt b/tests/baselines/reference/iterableArrayPattern10.errors.txt
new file mode 100644
index 00000000000..f06c4d7de17
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern10.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[any, any]'.
+  Property '0' is missing in type 'FooIterator'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts (1 errors) ====
+    function fun([a, b]) { }
+    fun(new FooIterator);
+        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[any, any]'.
+!!! error TS2345:   Property '0' is missing in type 'FooIterator'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern10.js b/tests/baselines/reference/iterableArrayPattern10.js
new file mode 100644
index 00000000000..c8d37e3f894
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern10.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern10.ts]
+function fun([a, b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern10.js]
+function fun([a, b]) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern11.js b/tests/baselines/reference/iterableArrayPattern11.js
new file mode 100644
index 00000000000..85ed4ab9710
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern11.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern11.ts]
+function fun([a, b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern11.js]
+function fun([a, b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern11.types b/tests/baselines/reference/iterableArrayPattern11.types
new file mode 100644
index 00000000000..2b6f1d67336
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern11.types
@@ -0,0 +1,52 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts ===
+function fun([a, b] = new FooIterator) { }
+>fun : ([a, b]?: FooIterator) => void
+>a : Foo
+>b : Foo
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+fun(new FooIterator);
+>fun(new FooIterator) : void
+>fun : ([a, b]?: FooIterator) => void
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern12.js b/tests/baselines/reference/iterableArrayPattern12.js
new file mode 100644
index 00000000000..4856af9cb48
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern12.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern12.ts]
+function fun([a, ...b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern12.js]
+function fun([a, ...b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern12.types b/tests/baselines/reference/iterableArrayPattern12.types
new file mode 100644
index 00000000000..a415539b91c
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern12.types
@@ -0,0 +1,52 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts ===
+function fun([a, ...b] = new FooIterator) { }
+>fun : ([a, ...b]?: FooIterator) => void
+>a : Foo
+>b : Foo[]
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+fun(new FooIterator);
+>fun(new FooIterator) : void
+>fun : ([a, ...b]?: FooIterator) => void
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern13.js b/tests/baselines/reference/iterableArrayPattern13.js
new file mode 100644
index 00000000000..06f9901a851
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern13.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern13.ts]
+function fun([a, ...b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern13.js]
+function fun([a, ...b]) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern13.types b/tests/baselines/reference/iterableArrayPattern13.types
new file mode 100644
index 00000000000..dbfbf9a1ebc
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern13.types
@@ -0,0 +1,50 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts ===
+function fun([a, ...b]) { }
+>fun : ([a, ...b]: Iterable<any>) => void
+>a : any
+>b : any[]
+
+fun(new FooIterator);
+>fun(new FooIterator) : void
+>fun : ([a, ...b]: Iterable<any>) => void
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern14.js b/tests/baselines/reference/iterableArrayPattern14.js
new file mode 100644
index 00000000000..a3595b0df0c
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern14.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern14.ts]
+function fun(...[a, ...b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern14.js]
+function fun(...[a, ...b]) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern14.types b/tests/baselines/reference/iterableArrayPattern14.types
new file mode 100644
index 00000000000..3f73f2973d1
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern14.types
@@ -0,0 +1,50 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts ===
+function fun(...[a, ...b]) { }
+>fun : (...[a, ...b]: any[]) => void
+>a : any
+>b : any[]
+
+fun(new FooIterator);
+>fun(new FooIterator) : void
+>fun : (...[a, ...b]: any[]) => void
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern15.js b/tests/baselines/reference/iterableArrayPattern15.js
new file mode 100644
index 00000000000..1c2050129ce
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern15.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern15.ts]
+function fun(...[a, b]: Bar[]) { }
+fun(...new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern15.js]
+function fun(...[a, b]) { }
+fun(...new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern15.types b/tests/baselines/reference/iterableArrayPattern15.types
new file mode 100644
index 00000000000..de548a91c26
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern15.types
@@ -0,0 +1,52 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts ===
+function fun(...[a, b]: Bar[]) { }
+>fun : (...[a, b]: Bar[]) => void
+>a : Bar
+>b : Bar
+>Bar : Bar
+
+fun(...new FooIterator);
+>fun(...new FooIterator) : void
+>fun : (...[a, b]: Bar[]) => void
+>...new FooIterator : Foo
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern16.errors.txt b/tests/baselines/reference/iterableArrayPattern16.errors.txt
new file mode 100644
index 00000000000..42236140be7
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern16.errors.txt
@@ -0,0 +1,37 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[Bar, Bar]'.
+  Property '0' is missing in type 'FooIterator'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts (1 errors) ====
+    function fun(...[a, b]: [Bar, Bar][]) { }
+    fun(...new FooIteratorIterator);
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[Bar, Bar]'.
+!!! error TS2345:   Property '0' is missing in type 'FooIterator'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
+    
+    class FooIteratorIterator {
+        next() {
+            return {
+                value: new FooIterator,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern16.js b/tests/baselines/reference/iterableArrayPattern16.js
new file mode 100644
index 00000000000..bda2ec37f63
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern16.js
@@ -0,0 +1,60 @@
+//// [iterableArrayPattern16.ts]
+function fun(...[a, b]: [Bar, Bar][]) { }
+fun(...new FooIteratorIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class FooIteratorIterator {
+    next() {
+        return {
+            value: new FooIterator,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern16.js]
+function fun(...[a, b]) { }
+fun(...new FooIteratorIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class FooIteratorIterator {
+    next() {
+        return {
+            value: new FooIterator,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern17.errors.txt b/tests/baselines/reference/iterableArrayPattern17.errors.txt
new file mode 100644
index 00000000000..306b00ea990
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern17.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar'.
+  Property 'x' is missing in type 'FooIterator'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts (1 errors) ====
+    function fun(...[a, b]: Bar[]) { }
+    fun(new FooIterator);
+        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar'.
+!!! error TS2345:   Property 'x' is missing in type 'FooIterator'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern17.js b/tests/baselines/reference/iterableArrayPattern17.js
new file mode 100644
index 00000000000..c6274aabcd9
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern17.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern17.ts]
+function fun(...[a, b]: Bar[]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern17.js]
+function fun(...[a, b]) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern18.errors.txt b/tests/baselines/reference/iterableArrayPattern18.errors.txt
new file mode 100644
index 00000000000..c6f8c5e28bd
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern18.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar[]'.
+  Property 'length' is missing in type 'FooIterator'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts (1 errors) ====
+    function fun([a, b]: Bar[]) { }
+    fun(new FooIterator);
+        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar[]'.
+!!! error TS2345:   Property 'length' is missing in type 'FooIterator'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern18.js b/tests/baselines/reference/iterableArrayPattern18.js
new file mode 100644
index 00000000000..e2016c47690
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern18.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern18.ts]
+function fun([a, b]: Bar[]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern18.js]
+function fun([a, b]) { }
+fun(new FooIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern19.errors.txt b/tests/baselines/reference/iterableArrayPattern19.errors.txt
new file mode 100644
index 00000000000..3f8b550d287
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern19.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts(2,5): error TS2345: Argument of type 'FooArrayIterator' is not assignable to parameter of type 'Bar[][]'.
+  Property 'length' is missing in type 'FooArrayIterator'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts (1 errors) ====
+    function fun([[a], b]: Bar[][]) { }
+    fun(new FooArrayIterator);
+        ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'FooArrayIterator' is not assignable to parameter of type 'Bar[][]'.
+!!! error TS2345:   Property 'length' is missing in type 'FooArrayIterator'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooArrayIterator {
+        next() {
+            return {
+                value: [new Foo],
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern19.js b/tests/baselines/reference/iterableArrayPattern19.js
new file mode 100644
index 00000000000..bc3cf33afc2
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern19.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern19.ts]
+function fun([[a], b]: Bar[][]) { }
+fun(new FooArrayIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern19.js]
+function fun([[a], b]) { }
+fun(new FooArrayIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern2.js b/tests/baselines/reference/iterableArrayPattern2.js
new file mode 100644
index 00000000000..7392db7d6b2
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern2.js
@@ -0,0 +1,28 @@
+//// [iterableArrayPattern2.ts]
+var [a, ...b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern2.js]
+var [a, ...b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern2.types b/tests/baselines/reference/iterableArrayPattern2.types
new file mode 100644
index 00000000000..819516dfe05
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern2.types
@@ -0,0 +1,36 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts ===
+var [a, ...b] = new SymbolIterator;
+>a : symbol
+>b : symbol[]
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern20.js b/tests/baselines/reference/iterableArrayPattern20.js
new file mode 100644
index 00000000000..489f97a29f3
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern20.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern20.ts]
+function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { }
+fun(...new FooArrayIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern20.js]
+function fun(...[[a = new Foo], b = [new Foo]]) { }
+fun(...new FooArrayIterator);
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern20.types b/tests/baselines/reference/iterableArrayPattern20.types
new file mode 100644
index 00000000000..055dfa95859
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern20.types
@@ -0,0 +1,58 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts ===
+function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { }
+>fun : (...[[a = new Foo], b = [new Foo]]: Bar[][]) => void
+>a : Bar
+>new Foo : Foo
+>Foo : typeof Foo
+>b : Bar[]
+>[new Foo] : Foo[]
+>new Foo : Foo
+>Foo : typeof Foo
+>Bar : Bar
+
+fun(...new FooArrayIterator);
+>fun(...new FooArrayIterator) : void
+>fun : (...[[a = new Foo], b = [new Foo]]: Bar[][]) => void
+>...new FooArrayIterator : Foo[]
+>new FooArrayIterator : FooArrayIterator
+>FooArrayIterator : typeof FooArrayIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooArrayIterator {
+>FooArrayIterator : FooArrayIterator
+
+    next() {
+>next : () => { value: Foo[]; done: boolean; }
+
+        return {
+>{            value: [new Foo],            done: false        } : { value: Foo[]; done: boolean; }
+
+            value: [new Foo],
+>value : Foo[]
+>[new Foo] : Foo[]
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooArrayIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern21.errors.txt b/tests/baselines/reference/iterableArrayPattern21.errors.txt
new file mode 100644
index 00000000000..7e853c90b24
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern21.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts(1,5): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts (1 errors) ====
+    var [a, b] = { 0: "", 1: true };
+        ~~~~~~
+!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern21.js b/tests/baselines/reference/iterableArrayPattern21.js
new file mode 100644
index 00000000000..bdc4d401e54
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern21.js
@@ -0,0 +1,5 @@
+//// [iterableArrayPattern21.ts]
+var [a, b] = { 0: "", 1: true };
+
+//// [iterableArrayPattern21.js]
+var [a, b] = { 0: "", 1: true };
diff --git a/tests/baselines/reference/iterableArrayPattern22.errors.txt b/tests/baselines/reference/iterableArrayPattern22.errors.txt
new file mode 100644
index 00000000000..3e40e4fd602
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern22.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts(1,5): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts (1 errors) ====
+    var [...a] = { 0: "", 1: true };
+        ~~~~~~
+!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern22.js b/tests/baselines/reference/iterableArrayPattern22.js
new file mode 100644
index 00000000000..9ec41bd3076
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern22.js
@@ -0,0 +1,5 @@
+//// [iterableArrayPattern22.ts]
+var [...a] = { 0: "", 1: true };
+
+//// [iterableArrayPattern22.js]
+var [...a] = { 0: "", 1: true };
diff --git a/tests/baselines/reference/iterableArrayPattern23.errors.txt b/tests/baselines/reference/iterableArrayPattern23.errors.txt
new file mode 100644
index 00000000000..1df5d909aed
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern23.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts(2,1): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts (1 errors) ====
+    var a: string, b: boolean;
+    [a, b] = { 0: "", 1: true };
+    ~~~~~~
+!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern23.js b/tests/baselines/reference/iterableArrayPattern23.js
new file mode 100644
index 00000000000..d932c29506d
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern23.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern23.ts]
+var a: string, b: boolean;
+[a, b] = { 0: "", 1: true };
+
+//// [iterableArrayPattern23.js]
+var a, b;
+[a, b] = { 0: "", 1: true };
diff --git a/tests/baselines/reference/iterableArrayPattern24.errors.txt b/tests/baselines/reference/iterableArrayPattern24.errors.txt
new file mode 100644
index 00000000000..e954c59f2ea
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern24.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts(2,1): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts (1 errors) ====
+    var a: string, b: boolean[];
+    [a, ...b] = { 0: "", 1: true };
+    ~~~~~~~~~
+!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern24.js b/tests/baselines/reference/iterableArrayPattern24.js
new file mode 100644
index 00000000000..f089e35dad8
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern24.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern24.ts]
+var a: string, b: boolean[];
+[a, ...b] = { 0: "", 1: true };
+
+//// [iterableArrayPattern24.js]
+var a, b;
+[a, ...b] = { 0: "", 1: true };
diff --git a/tests/baselines/reference/iterableArrayPattern25.errors.txt b/tests/baselines/reference/iterableArrayPattern25.errors.txt
new file mode 100644
index 00000000000..cc901523b55
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern25.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts(1,30): error TS2370: A rest parameter must be of an array type.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts (1 errors) ====
+    function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+                                 ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2370: A rest parameter must be of an array type.
+    takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern25.js b/tests/baselines/reference/iterableArrayPattern25.js
new file mode 100644
index 00000000000..1dc44c0dba7
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern25.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern25.ts]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
+
+//// [iterableArrayPattern25.js]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
diff --git a/tests/baselines/reference/iterableArrayPattern26.errors.txt b/tests/baselines/reference/iterableArrayPattern26.errors.txt
new file mode 100644
index 00000000000..9fb3e688039
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern26.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts(2,21): error TS2345: Argument of type 'Map<string, number>' is not assignable to parameter of type '[string, number]'.
+  Property '0' is missing in type 'Map<string, number>'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts (1 errors) ====
+    function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+    takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
+                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'Map<string, number>' is not assignable to parameter of type '[string, number]'.
+!!! error TS2345:   Property '0' is missing in type 'Map<string, number>'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern26.js b/tests/baselines/reference/iterableArrayPattern26.js
new file mode 100644
index 00000000000..63c188febb7
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern26.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern26.ts]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
+
+//// [iterableArrayPattern26.js]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
diff --git a/tests/baselines/reference/iterableArrayPattern27.js b/tests/baselines/reference/iterableArrayPattern27.js
new file mode 100644
index 00000000000..3e936eb51f4
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern27.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern27.ts]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]]));
+
+//// [iterableArrayPattern27.js]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]]));
diff --git a/tests/baselines/reference/iterableArrayPattern27.types b/tests/baselines/reference/iterableArrayPattern27.types
new file mode 100644
index 00000000000..72d13ee0e00
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern27.types
@@ -0,0 +1,18 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts ===
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+>takeFirstTwoEntries : (...[[k1, v1], [k2, v2]]: [string, number][]) => void
+>k1 : string
+>v1 : number
+>k2 : string
+>v2 : number
+
+takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]]));
+>takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]])) : void
+>takeFirstTwoEntries : (...[[k1, v1], [k2, v2]]: [string, number][]) => void
+>...new Map([["", 0], ["hello", 1]]) : [string, number]
+>new Map([["", 0], ["hello", 1]]) : Map<string, number>
+>Map : MapConstructor
+>[["", 0], ["hello", 1]] : [string, number][]
+>["", 0] : [string, number]
+>["hello", 1] : [string, number]
+
diff --git a/tests/baselines/reference/iterableArrayPattern28.errors.txt b/tests/baselines/reference/iterableArrayPattern28.errors.txt
new file mode 100644
index 00000000000..0190dd939e8
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern28.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts(2,28): error TS2453: The type argument for type parameter 'V' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate 'number' is not a valid type argument because it is not a supertype of candidate 'boolean'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts (1 errors) ====
+    function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+    takeFirstTwoEntries(...new Map([["", 0], ["hello", true]]));
+                               ~~~
+!!! error TS2453: The type argument for type parameter 'V' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate 'number' is not a valid type argument because it is not a supertype of candidate 'boolean'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern28.js b/tests/baselines/reference/iterableArrayPattern28.js
new file mode 100644
index 00000000000..70953475372
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern28.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern28.ts]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", true]]));
+
+//// [iterableArrayPattern28.js]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", true]]));
diff --git a/tests/baselines/reference/iterableArrayPattern29.errors.txt b/tests/baselines/reference/iterableArrayPattern29.errors.txt
new file mode 100644
index 00000000000..632854ae952
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern29.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(2,21): error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'.
+  Types of property '1' are incompatible.
+    Type 'boolean' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts (1 errors) ====
+    function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+    takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
+                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'.
+!!! error TS2345:   Types of property '1' are incompatible.
+!!! error TS2345:     Type 'boolean' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern29.js b/tests/baselines/reference/iterableArrayPattern29.js
new file mode 100644
index 00000000000..912d336263f
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern29.js
@@ -0,0 +1,7 @@
+//// [iterableArrayPattern29.ts]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
+
+//// [iterableArrayPattern29.js]
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
diff --git a/tests/baselines/reference/iterableArrayPattern3.js b/tests/baselines/reference/iterableArrayPattern3.js
new file mode 100644
index 00000000000..7136c6ab209
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern3.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern3.ts]
+var a: Bar, b: Bar;
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern3.js]
+var a, b;
+[a, b] = new FooIterator;
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern3.types b/tests/baselines/reference/iterableArrayPattern3.types
new file mode 100644
index 00000000000..291eed9723a
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern3.types
@@ -0,0 +1,53 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts ===
+var a: Bar, b: Bar;
+>a : Bar
+>Bar : Bar
+>b : Bar
+>Bar : Bar
+
+[a, b] = new FooIterator;
+>[a, b] = new FooIterator : FooIterator
+>[a, b] : [Bar, Bar]
+>a : Bar
+>b : Bar
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern30.js b/tests/baselines/reference/iterableArrayPattern30.js
new file mode 100644
index 00000000000..10f7df53aa3
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern30.js
@@ -0,0 +1,5 @@
+//// [iterableArrayPattern30.ts]
+const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
+
+//// [iterableArrayPattern30.js]
+const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]);
diff --git a/tests/baselines/reference/iterableArrayPattern30.types b/tests/baselines/reference/iterableArrayPattern30.types
new file mode 100644
index 00000000000..998da11d651
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern30.types
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts ===
+const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
+>k1 : string
+>v1 : boolean
+>k2 : string
+>v2 : boolean
+>new Map([["", true], ["hello", true]]) : Map<string, boolean>
+>Map : MapConstructor
+>[["", true], ["hello", true]] : [string, boolean][]
+>["", true] : [string, boolean]
+>["hello", true] : [string, boolean]
+
diff --git a/tests/baselines/reference/iterableArrayPattern4.js b/tests/baselines/reference/iterableArrayPattern4.js
new file mode 100644
index 00000000000..6e60dadbd7a
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern4.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern4.ts]
+var a: Bar, b: Bar[];
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern4.js]
+var a, b;
+[a, ...b] = new FooIterator;
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern4.types b/tests/baselines/reference/iterableArrayPattern4.types
new file mode 100644
index 00000000000..531b2aa8275
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern4.types
@@ -0,0 +1,54 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts ===
+var a: Bar, b: Bar[];
+>a : Bar
+>Bar : Bar
+>b : Bar[]
+>Bar : Bar
+
+[a, ...b] = new FooIterator;
+>[a, ...b] = new FooIterator : FooIterator
+>[a, ...b] : Bar[]
+>a : Bar
+>...b : Bar
+>b : Bar[]
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern5.errors.txt b/tests/baselines/reference/iterableArrayPattern5.errors.txt
new file mode 100644
index 00000000000..ca540d805be
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern5.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts(2,5): error TS2322: Type 'Foo' is not assignable to type 'string'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts (1 errors) ====
+    var a: Bar, b: string;
+    [a, b] = new FooIterator;
+        ~
+!!! error TS2322: Type 'Foo' is not assignable to type 'string'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern5.js b/tests/baselines/reference/iterableArrayPattern5.js
new file mode 100644
index 00000000000..77e71cac6d3
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern5.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern5.ts]
+var a: Bar, b: string;
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern5.js]
+var a, b;
+[a, b] = new FooIterator;
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern6.errors.txt b/tests/baselines/reference/iterableArrayPattern6.errors.txt
new file mode 100644
index 00000000000..e0a546d154c
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern6.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts(2,8): error TS2322: Type 'Foo[]' is not assignable to type 'string[]'.
+  Type 'Foo' is not assignable to type 'string'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts (1 errors) ====
+    var a: Bar, b: string[];
+    [a, ...b] = new FooIterator;
+           ~
+!!! error TS2322: Type 'Foo[]' is not assignable to type 'string[]'.
+!!! error TS2322:   Type 'Foo' is not assignable to type 'string'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern6.js b/tests/baselines/reference/iterableArrayPattern6.js
new file mode 100644
index 00000000000..8c797e819f5
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern6.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern6.ts]
+var a: Bar, b: string[];
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern6.js]
+var a, b;
+[a, ...b] = new FooIterator;
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern7.errors.txt b/tests/baselines/reference/iterableArrayPattern7.errors.txt
new file mode 100644
index 00000000000..997cc21f38b
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern7.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts(2,5): error TS2322: Type 'Foo' is not assignable to type 'string[]'.
+  Property 'length' is missing in type 'Foo'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts (1 errors) ====
+    var a: Bar, b: string[];
+    [a, b] = new FooIterator;
+        ~
+!!! error TS2322: Type 'Foo' is not assignable to type 'string[]'.
+!!! error TS2322:   Property 'length' is missing in type 'Foo'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern7.js b/tests/baselines/reference/iterableArrayPattern7.js
new file mode 100644
index 00000000000..3f79e6bfba8
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern7.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern7.ts]
+var a: Bar, b: string[];
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern7.js]
+var a, b;
+[a, b] = new FooIterator;
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern8.errors.txt b/tests/baselines/reference/iterableArrayPattern8.errors.txt
new file mode 100644
index 00000000000..c06e0c9543f
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern8.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts(2,8): error TS2322: Type 'Foo[]' is not assignable to type 'string'.
+
+
+==== tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts (1 errors) ====
+    var a: Bar, b: string;
+    [a, ...b] = new FooIterator;
+           ~
+!!! error TS2322: Type 'Foo[]' is not assignable to type 'string'.
+    class Bar { x }
+    class Foo extends Bar { y }
+    class FooIterator {
+        next() {
+            return {
+                value: new Foo,
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iterableArrayPattern8.js b/tests/baselines/reference/iterableArrayPattern8.js
new file mode 100644
index 00000000000..dd1c76c1f51
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern8.js
@@ -0,0 +1,36 @@
+//// [iterableArrayPattern8.ts]
+var a: Bar, b: string;
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern8.js]
+var a, b;
+[a, ...b] = new FooIterator;
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern9.js b/tests/baselines/reference/iterableArrayPattern9.js
new file mode 100644
index 00000000000..a85ca9c347b
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern9.js
@@ -0,0 +1,34 @@
+//// [iterableArrayPattern9.ts]
+function fun([a, b] = new FooIterator) { }
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iterableArrayPattern9.js]
+function fun([a, b] = new FooIterator) { }
+class Bar {
+}
+class Foo extends Bar {
+}
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iterableArrayPattern9.types b/tests/baselines/reference/iterableArrayPattern9.types
new file mode 100644
index 00000000000..67d4bab1a83
--- /dev/null
+++ b/tests/baselines/reference/iterableArrayPattern9.types
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts ===
+function fun([a, b] = new FooIterator) { }
+>fun : ([a, b]?: FooIterator) => void
+>a : Foo
+>b : Foo
+>new FooIterator : FooIterator
+>FooIterator : typeof FooIterator
+
+class Bar { x }
+>Bar : Bar
+>x : any
+
+class Foo extends Bar { y }
+>Foo : Foo
+>Bar : Bar
+>y : any
+
+class FooIterator {
+>FooIterator : FooIterator
+
+    next() {
+>next : () => { value: Foo; done: boolean; }
+
+        return {
+>{            value: new Foo,            done: false        } : { value: Foo; done: boolean; }
+
+            value: new Foo,
+>value : Foo
+>new Foo : Foo
+>Foo : typeof Foo
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : FooIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray.js b/tests/baselines/reference/iteratorSpreadInArray.js
new file mode 100644
index 00000000000..8e25a2e7ecf
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray.js
@@ -0,0 +1,29 @@
+//// [iteratorSpreadInArray.ts]
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray.js]
+var array = [...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray.types b/tests/baselines/reference/iteratorSpreadInArray.types
new file mode 100644
index 00000000000..13b1a458eb9
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts ===
+var array = [...new SymbolIterator];
+>array : symbol[]
+>[...new SymbolIterator] : symbol[]
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray10.errors.txt b/tests/baselines/reference/iteratorSpreadInArray10.errors.txt
new file mode 100644
index 00000000000..90cde7d03b1
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray10.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts(1,17): error TS2489: An iterator must have a 'next()' method.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts (1 errors) ====
+    var array = [...new SymbolIterator];
+                    ~~~~~~~~~~~~~~~~~~
+!!! error TS2489: An iterator must have a 'next()' method.
+    
+    class SymbolIterator {
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInArray10.js b/tests/baselines/reference/iteratorSpreadInArray10.js
new file mode 100644
index 00000000000..1004dbd7b34
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray10.js
@@ -0,0 +1,16 @@
+//// [iteratorSpreadInArray10.ts]
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray10.js]
+var array = [...new SymbolIterator];
+class SymbolIterator {
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray11.js b/tests/baselines/reference/iteratorSpreadInArray11.js
new file mode 100644
index 00000000000..fa86c152123
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray11.js
@@ -0,0 +1,7 @@
+//// [iteratorSpreadInArray11.ts]
+var iter: Iterable<number>;
+var array = [...iter];
+
+//// [iteratorSpreadInArray11.js]
+var iter;
+var array = [...iter];
diff --git a/tests/baselines/reference/iteratorSpreadInArray11.types b/tests/baselines/reference/iteratorSpreadInArray11.types
new file mode 100644
index 00000000000..a3ed7826e07
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray11.types
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts ===
+var iter: Iterable<number>;
+>iter : Iterable<number>
+>Iterable : Iterable<T>
+
+var array = [...iter];
+>array : number[]
+>[...iter] : number[]
+>...iter : number
+>iter : Iterable<number>
+
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.js b/tests/baselines/reference/iteratorSpreadInArray2.js
new file mode 100644
index 00000000000..aa4a1099a40
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray2.js
@@ -0,0 +1,53 @@
+//// [iteratorSpreadInArray2.ts]
+var array = [...new NumberIterator, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class NumberIterator {
+    next() {
+        return {
+            value: 0,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray2.js]
+var array = [...new NumberIterator, ...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class NumberIterator {
+    next() {
+        return {
+            value: 0,
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.types b/tests/baselines/reference/iteratorSpreadInArray2.types
new file mode 100644
index 00000000000..3cb27445f57
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray2.types
@@ -0,0 +1,68 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts ===
+var array = [...new NumberIterator, ...new SymbolIterator];
+>array : (number | symbol)[]
+>[...new NumberIterator, ...new SymbolIterator] : (number | symbol)[]
+>...new NumberIterator : number
+>new NumberIterator : NumberIterator
+>NumberIterator : typeof NumberIterator
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
+
+class NumberIterator {
+>NumberIterator : NumberIterator
+
+    next() {
+>next : () => { value: number; done: boolean; }
+
+        return {
+>{            value: 0,            done: false        } : { value: number; done: boolean; }
+
+            value: 0,
+>value : number
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : NumberIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.js b/tests/baselines/reference/iteratorSpreadInArray3.js
new file mode 100644
index 00000000000..1d468e4483e
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray3.js
@@ -0,0 +1,29 @@
+//// [iteratorSpreadInArray3.ts]
+var array = [...[0, 1], ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray3.js]
+var array = [...[0, 1], ...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.types b/tests/baselines/reference/iteratorSpreadInArray3.types
new file mode 100644
index 00000000000..e5c25daabc7
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray3.types
@@ -0,0 +1,39 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts ===
+var array = [...[0, 1], ...new SymbolIterator];
+>array : (number | symbol)[]
+>[...[0, 1], ...new SymbolIterator] : (number | symbol)[]
+>...[0, 1] : number
+>[0, 1] : number[]
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.js b/tests/baselines/reference/iteratorSpreadInArray4.js
new file mode 100644
index 00000000000..82a08bfa964
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray4.js
@@ -0,0 +1,29 @@
+//// [iteratorSpreadInArray4.ts]
+var array = [0, 1, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray4.js]
+var array = [0, 1, ...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.types b/tests/baselines/reference/iteratorSpreadInArray4.types
new file mode 100644
index 00000000000..790fc9db1ba
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray4.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts ===
+var array = [0, 1, ...new SymbolIterator];
+>array : (number | symbol)[]
+>[0, 1, ...new SymbolIterator] : (number | symbol)[]
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray5.errors.txt b/tests/baselines/reference/iteratorSpreadInArray5.errors.txt
new file mode 100644
index 00000000000..498cc7d48ef
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray5.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts(1,5): error TS2322: Type '(number | symbol)[]' is not assignable to type 'number[]'.
+  Type 'number | symbol' is not assignable to type 'number'.
+    Type 'symbol' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts (1 errors) ====
+    var array: number[] = [0, 1, ...new SymbolIterator];
+        ~~~~~
+!!! error TS2322: Type '(number | symbol)[]' is not assignable to type 'number[]'.
+!!! error TS2322:   Type 'number | symbol' is not assignable to type 'number'.
+!!! error TS2322:     Type 'symbol' is not assignable to type 'number'.
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInArray5.js b/tests/baselines/reference/iteratorSpreadInArray5.js
new file mode 100644
index 00000000000..0aa158a5dc2
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray5.js
@@ -0,0 +1,29 @@
+//// [iteratorSpreadInArray5.ts]
+var array: number[] = [0, 1, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray5.js]
+var array = [0, 1, ...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray6.errors.txt b/tests/baselines/reference/iteratorSpreadInArray6.errors.txt
new file mode 100644
index 00000000000..b90ac5f203c
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray6.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(2,14): error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts (1 errors) ====
+    var array: number[] = [0, 1];
+    array.concat([...new SymbolIterator]);
+                 ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number'.
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInArray6.js b/tests/baselines/reference/iteratorSpreadInArray6.js
new file mode 100644
index 00000000000..02d1c435b8c
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray6.js
@@ -0,0 +1,31 @@
+//// [iteratorSpreadInArray6.ts]
+var array: number[] = [0, 1];
+array.concat([...new SymbolIterator]);
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray6.js]
+var array = [0, 1];
+array.concat([...new SymbolIterator]);
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.js b/tests/baselines/reference/iteratorSpreadInArray7.js
new file mode 100644
index 00000000000..72a614ae4ec
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray7.js
@@ -0,0 +1,31 @@
+//// [iteratorSpreadInArray7.ts]
+var array: symbol[];
+array.concat([...new SymbolIterator]);
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray7.js]
+var array;
+array.concat([...new SymbolIterator]);
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.types b/tests/baselines/reference/iteratorSpreadInArray7.types
new file mode 100644
index 00000000000..c58d01f098b
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray7.types
@@ -0,0 +1,43 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts ===
+var array: symbol[];
+>array : symbol[]
+
+array.concat([...new SymbolIterator]);
+>array.concat([...new SymbolIterator]) : symbol[]
+>array.concat : { <U extends symbol[]>(...items: U[]): symbol[]; (...items: symbol[]): symbol[]; }
+>array : symbol[]
+>concat : { <U extends symbol[]>(...items: U[]): symbol[]; (...items: symbol[]): symbol[]; }
+>[...new SymbolIterator] : symbol[]
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray8.errors.txt b/tests/baselines/reference/iteratorSpreadInArray8.errors.txt
new file mode 100644
index 00000000000..365bc8db9c2
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray8.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts(1,17): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts (1 errors) ====
+    var array = [...new SymbolIterator];
+                    ~~~~~~~~~~~~~~~~~~
+!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInArray8.js b/tests/baselines/reference/iteratorSpreadInArray8.js
new file mode 100644
index 00000000000..08378699129
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray8.js
@@ -0,0 +1,22 @@
+//// [iteratorSpreadInArray8.ts]
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+}
+
+//// [iteratorSpreadInArray8.js]
+var array = [...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInArray9.errors.txt b/tests/baselines/reference/iteratorSpreadInArray9.errors.txt
new file mode 100644
index 00000000000..e0e3d061f16
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray9.errors.txt
@@ -0,0 +1,33 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts(1,17): error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterable<symbol>'.
+  Types of property '[Symbol.iterator]' are incompatible.
+    Type '() => SymbolIterator' is not assignable to type '() => Iterator<symbol>'.
+      Type 'SymbolIterator' is not assignable to type 'Iterator<symbol>'.
+        Types of property 'next' are incompatible.
+          Type '() => { value: symbol; }' is not assignable to type '() => IteratorResult<symbol>'.
+            Type '{ value: symbol; }' is not assignable to type 'IteratorResult<symbol>'.
+              Property 'done' is missing in type '{ value: symbol; }'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts (1 errors) ====
+    var array = [...new SymbolIterator];
+                    ~~~~~~~~~~~~~~~~~~
+!!! error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterable<symbol>'.
+!!! error TS2322:   Types of property '[Symbol.iterator]' are incompatible.
+!!! error TS2322:     Type '() => SymbolIterator' is not assignable to type '() => Iterator<symbol>'.
+!!! error TS2322:       Type 'SymbolIterator' is not assignable to type 'Iterator<symbol>'.
+!!! error TS2322:         Types of property 'next' are incompatible.
+!!! error TS2322:           Type '() => { value: symbol; }' is not assignable to type '() => IteratorResult<symbol>'.
+!!! error TS2322:             Type '{ value: symbol; }' is not assignable to type 'IteratorResult<symbol>'.
+!!! error TS2322:               Property 'done' is missing in type '{ value: symbol; }'.
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol()
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInArray9.js b/tests/baselines/reference/iteratorSpreadInArray9.js
new file mode 100644
index 00000000000..ed0a9b4ebe9
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInArray9.js
@@ -0,0 +1,27 @@
+//// [iteratorSpreadInArray9.ts]
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol()
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInArray9.js]
+var array = [...new SymbolIterator];
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol()
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall.errors.txt b/tests/baselines/reference/iteratorSpreadInCall.errors.txt
new file mode 100644
index 00000000000..614153192d7
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts (1 errors) ====
+    foo(...new SymbolIterator);
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    function foo(s: symbol) { }
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall.js b/tests/baselines/reference/iteratorSpreadInCall.js
new file mode 100644
index 00000000000..f3bf17c0327
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall.js
@@ -0,0 +1,31 @@
+//// [iteratorSpreadInCall.ts]
+foo(...new SymbolIterator);
+
+function foo(s: symbol) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall.js]
+foo(...new SymbolIterator);
+function foo(s) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall10.errors.txt b/tests/baselines/reference/iteratorSpreadInCall10.errors.txt
new file mode 100644
index 00000000000..04d9045e86c
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall10.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts (1 errors) ====
+    foo(...new SymbolIterator);
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    function foo<T>(s: T[]) { return s[0] }
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall10.js b/tests/baselines/reference/iteratorSpreadInCall10.js
new file mode 100644
index 00000000000..14a08c97009
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall10.js
@@ -0,0 +1,32 @@
+//// [iteratorSpreadInCall10.ts]
+foo(...new SymbolIterator);
+
+function foo<T>(s: T[]) { return s[0] }
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall10.js]
+foo(...new SymbolIterator);
+function foo(s) { return s[0]; }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.js b/tests/baselines/reference/iteratorSpreadInCall11.js
new file mode 100644
index 00000000000..d01eb259ef3
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall11.js
@@ -0,0 +1,32 @@
+//// [iteratorSpreadInCall11.ts]
+foo(...new SymbolIterator);
+
+function foo<T>(...s: T[]) { return s[0] }
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall11.js]
+foo(...new SymbolIterator);
+function foo(...s) { return s[0]; }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.types b/tests/baselines/reference/iteratorSpreadInCall11.types
new file mode 100644
index 00000000000..a37fc6e2232
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall11.types
@@ -0,0 +1,45 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts ===
+foo(...new SymbolIterator);
+>foo(...new SymbolIterator) : symbol
+>foo : <T>(...s: T[]) => T
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+function foo<T>(...s: T[]) { return s[0] }
+>foo : <T>(...s: T[]) => T
+>T : T
+>s : T[]
+>T : T
+>s[0] : T
+>s : T[]
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.js b/tests/baselines/reference/iteratorSpreadInCall12.js
new file mode 100644
index 00000000000..90b9d9b900b
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall12.js
@@ -0,0 +1,61 @@
+//// [iteratorSpreadInCall12.ts]
+new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall12.js]
+new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+class Foo {
+    constructor(...s) {
+    }
+}
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.types b/tests/baselines/reference/iteratorSpreadInCall12.types
new file mode 100644
index 00000000000..78ce973a532
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall12.types
@@ -0,0 +1,81 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts ===
+new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+>new Foo(...[...new SymbolIterator, ...[...new StringIterator]]) : Foo<string | symbol>
+>Foo : typeof Foo
+>...[...new SymbolIterator, ...[...new StringIterator]] : string | symbol
+>[...new SymbolIterator, ...[...new StringIterator]] : (string | symbol)[]
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+>...[...new StringIterator] : string
+>[...new StringIterator] : string[]
+>...new StringIterator : string
+>new StringIterator : StringIterator
+>StringIterator : typeof StringIterator
+
+class Foo<T> {
+>Foo : Foo<T>
+>T : T
+
+    constructor(...s: T[]) { }
+>s : T[]
+>T : T
+}
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
+
+class StringIterator {
+>StringIterator : StringIterator
+
+    next() {
+>next : () => { value: string; done: boolean; }
+
+        return {
+>{            value: "",            done: false        } : { value: string; done: boolean; }
+
+            value: "",
+>value : string
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : StringIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall2.errors.txt b/tests/baselines/reference/iteratorSpreadInCall2.errors.txt
new file mode 100644
index 00000000000..bd994ab37b0
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall2.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts (1 errors) ====
+    foo(...new SymbolIterator);
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    function foo(s: symbol[]) { }
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall2.js b/tests/baselines/reference/iteratorSpreadInCall2.js
new file mode 100644
index 00000000000..6c3517857d5
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall2.js
@@ -0,0 +1,31 @@
+//// [iteratorSpreadInCall2.ts]
+foo(...new SymbolIterator);
+
+function foo(s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall2.js]
+foo(...new SymbolIterator);
+function foo(s) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.js b/tests/baselines/reference/iteratorSpreadInCall3.js
new file mode 100644
index 00000000000..b33ceae7bfd
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall3.js
@@ -0,0 +1,31 @@
+//// [iteratorSpreadInCall3.ts]
+foo(...new SymbolIterator);
+
+function foo(...s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall3.js]
+foo(...new SymbolIterator);
+function foo(...s) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.types b/tests/baselines/reference/iteratorSpreadInCall3.types
new file mode 100644
index 00000000000..07eb149ba31
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall3.types
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts ===
+foo(...new SymbolIterator);
+>foo(...new SymbolIterator) : void
+>foo : (...s: symbol[]) => void
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+
+function foo(...s: symbol[]) { }
+>foo : (...s: symbol[]) => void
+>s : symbol[]
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall4.errors.txt b/tests/baselines/reference/iteratorSpreadInCall4.errors.txt
new file mode 100644
index 00000000000..0e0a40a512f
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall4.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts (1 errors) ====
+    foo(...new SymbolIterator);
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    function foo(s1: symbol, ...s: symbol[]) { }
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall4.js b/tests/baselines/reference/iteratorSpreadInCall4.js
new file mode 100644
index 00000000000..7819a1ba6f9
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall4.js
@@ -0,0 +1,31 @@
+//// [iteratorSpreadInCall4.ts]
+foo(...new SymbolIterator);
+
+function foo(s1: symbol, ...s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall4.js]
+foo(...new SymbolIterator);
+function foo(s1, ...s) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.js b/tests/baselines/reference/iteratorSpreadInCall5.js
new file mode 100644
index 00000000000..a4a30ee0166
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall5.js
@@ -0,0 +1,55 @@
+//// [iteratorSpreadInCall5.ts]
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo(...s: (symbol | string)[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall5.js]
+foo(...new SymbolIterator, ...new StringIterator);
+function foo(...s) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.types b/tests/baselines/reference/iteratorSpreadInCall5.types
new file mode 100644
index 00000000000..6e924a1ef42
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall5.types
@@ -0,0 +1,72 @@
+=== tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts ===
+foo(...new SymbolIterator, ...new StringIterator);
+>foo(...new SymbolIterator, ...new StringIterator) : void
+>foo : (...s: (string | symbol)[]) => void
+>...new SymbolIterator : symbol
+>new SymbolIterator : SymbolIterator
+>SymbolIterator : typeof SymbolIterator
+>...new StringIterator : string
+>new StringIterator : StringIterator
+>StringIterator : typeof StringIterator
+
+function foo(...s: (symbol | string)[]) { }
+>foo : (...s: (string | symbol)[]) => void
+>s : (string | symbol)[]
+
+class SymbolIterator {
+>SymbolIterator : SymbolIterator
+
+    next() {
+>next : () => { value: symbol; done: boolean; }
+
+        return {
+>{            value: Symbol(),            done: false        } : { value: symbol; done: boolean; }
+
+            value: Symbol(),
+>value : symbol
+>Symbol() : symbol
+>Symbol : SymbolConstructor
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : SymbolIterator
+    }
+}
+
+class StringIterator {
+>StringIterator : StringIterator
+
+    next() {
+>next : () => { value: string; done: boolean; }
+
+        return {
+>{            value: "",            done: false        } : { value: string; done: boolean; }
+
+            value: "",
+>value : string
+
+            done: false
+>done : boolean
+
+        };
+    }
+
+    [Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+        return this;
+>this : StringIterator
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.errors.txt b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt
new file mode 100644
index 00000000000..be085beb632
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt
@@ -0,0 +1,36 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts(1,28): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'.
+  Type 'string' is not assignable to type 'symbol'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts (1 errors) ====
+    foo(...new SymbolIterator, ...new StringIterator);
+                               ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'.
+!!! error TS2345:   Type 'string' is not assignable to type 'symbol'.
+    
+    function foo(...s: (symbol | number)[]) { }
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
+    
+    class StringIterator {
+        next() {
+            return {
+                value: "",
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.js b/tests/baselines/reference/iteratorSpreadInCall6.js
new file mode 100644
index 00000000000..8ad60be911e
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall6.js
@@ -0,0 +1,55 @@
+//// [iteratorSpreadInCall6.ts]
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo(...s: (symbol | number)[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall6.js]
+foo(...new SymbolIterator, ...new StringIterator);
+function foo(...s) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.errors.txt b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt
new file mode 100644
index 00000000000..51cae1d72b2
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt
@@ -0,0 +1,36 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts(1,1): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts (1 errors) ====
+    foo(...new SymbolIterator, ...new StringIterator);
+    ~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'.
+    
+    function foo<T>(...s: T[]) { return s[0]; }
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
+    
+    class StringIterator {
+        next() {
+            return {
+                value: "",
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.js b/tests/baselines/reference/iteratorSpreadInCall7.js
new file mode 100644
index 00000000000..4a56b75d236
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall7.js
@@ -0,0 +1,55 @@
+//// [iteratorSpreadInCall7.ts]
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo<T>(...s: T[]) { return s[0]; }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall7.js]
+foo(...new SymbolIterator, ...new StringIterator);
+function foo(...s) { return s[0]; }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.errors.txt b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt
new file mode 100644
index 00000000000..d7913458b6a
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt
@@ -0,0 +1,39 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts(1,5): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts (1 errors) ====
+    new Foo(...new SymbolIterator, ...new StringIterator);
+        ~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'.
+    
+    class Foo<T> {
+        constructor(...s: T[]) { }
+    }
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
+    
+    class StringIterator {
+        next() {
+            return {
+                value: "",
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.js b/tests/baselines/reference/iteratorSpreadInCall8.js
new file mode 100644
index 00000000000..ac22bbcf5a3
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall8.js
@@ -0,0 +1,61 @@
+//// [iteratorSpreadInCall8.ts]
+new Foo(...new SymbolIterator, ...new StringIterator);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall8.js]
+new Foo(...new SymbolIterator, ...new StringIterator);
+class Foo {
+    constructor(...s) {
+    }
+}
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.errors.txt b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt
new file mode 100644
index 00000000000..da2ee7f8efc
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt
@@ -0,0 +1,39 @@
+tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts(1,5): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+  Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'.
+
+
+==== tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts (1 errors) ====
+    new Foo(...new SymbolIterator, ...[...new StringIterator]);
+        ~~~
+!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS2453:   Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'.
+    
+    class Foo<T> {
+        constructor(...s: T[]) { }
+    }
+    
+    class SymbolIterator {
+        next() {
+            return {
+                value: Symbol(),
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
+    
+    class StringIterator {
+        next() {
+            return {
+                value: "",
+                done: false
+            };
+        }
+    
+        [Symbol.iterator]() {
+            return this;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.js b/tests/baselines/reference/iteratorSpreadInCall9.js
new file mode 100644
index 00000000000..2a73ee29c34
--- /dev/null
+++ b/tests/baselines/reference/iteratorSpreadInCall9.js
@@ -0,0 +1,61 @@
+//// [iteratorSpreadInCall9.ts]
+new Foo(...new SymbolIterator, ...[...new StringIterator]);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+//// [iteratorSpreadInCall9.js]
+new Foo(...new SymbolIterator, ...[...new StringIterator]);
+class Foo {
+    constructor(...s) {
+    }
+}
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
diff --git a/tests/baselines/reference/parserES5ComputedPropertyName2.js b/tests/baselines/reference/parserES5ComputedPropertyName2.js
index d8a5bb45fac..4569c00d7b3 100644
--- a/tests/baselines/reference/parserES5ComputedPropertyName2.js
+++ b/tests/baselines/reference/parserES5ComputedPropertyName2.js
@@ -2,7 +2,5 @@
 var v = { [e]: 1 };
 
 //// [parserES5ComputedPropertyName2.js]
-var v = (_a = {},
-    _a[e] = 1,
-    _a);
+var v = (_a = {}, _a[e] = 1, _a);
 var _a;
diff --git a/tests/baselines/reference/parserES5ComputedPropertyName3.js b/tests/baselines/reference/parserES5ComputedPropertyName3.js
index 26067467953..1fdb5ced65d 100644
--- a/tests/baselines/reference/parserES5ComputedPropertyName3.js
+++ b/tests/baselines/reference/parserES5ComputedPropertyName3.js
@@ -2,7 +2,5 @@
 var v = { [e]() { } };
 
 //// [parserES5ComputedPropertyName3.js]
-var v = (_a = {},
-    _a[e] = function () { },
-    _a);
+var v = (_a = {}, _a[e] = function () { }, _a);
 var _a;
diff --git a/tests/baselines/reference/parserES5ComputedPropertyName4.js b/tests/baselines/reference/parserES5ComputedPropertyName4.js
index 378624af08b..499e9a426d9 100644
--- a/tests/baselines/reference/parserES5ComputedPropertyName4.js
+++ b/tests/baselines/reference/parserES5ComputedPropertyName4.js
@@ -2,7 +2,9 @@
 var v = { get [e]() { } };
 
 //// [parserES5ComputedPropertyName4.js]
-var v = (_a = {},
-    _a[e] = Object.defineProperty({ get: function () { }, enumerable: true, configurable: true }),
-    _a);
+var v = (_a = {}, Object.defineProperty(_a, e, {
+    get: function () { },
+    enumerable: true,
+    configurable: true
+}), _a);
 var _a;
diff --git a/tests/baselines/reference/privateIndexer2.js b/tests/baselines/reference/privateIndexer2.js
index a90e03a5bc2..1268c6e4c25 100644
--- a/tests/baselines/reference/privateIndexer2.js
+++ b/tests/baselines/reference/privateIndexer2.js
@@ -14,6 +14,7 @@ var y: {
 var x = (_a = {},
     _a[x] = string,
     _a.string = ,
-    _a);
+    _a
+);
 var y;
 var _a;
diff --git a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts
new file mode 100644
index 00000000000..e3d94ff25d2
--- /dev/null
+++ b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts
@@ -0,0 +1,9 @@
+// @target: ES5
+module M {
+    class C {
+        decorator(target: Object, key: string): void { }
+
+        @this.decorator
+        method() { }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts
new file mode 100644
index 00000000000..a9a2607c39b
--- /dev/null
+++ b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts
@@ -0,0 +1,10 @@
+// @target: ES5
+module M {
+    class S {
+        decorator(target: Object, key: string): void { }
+    }
+    class C extends S {
+        @super.decorator
+        method() { }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts
new file mode 100644
index 00000000000..df0b847e99d
--- /dev/null
+++ b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod13.ts
@@ -0,0 +1,7 @@
+// @target: ES6
+declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+
+class C {
+    @dec ["1"]() { }
+    @dec ["b"]() { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts
new file mode 100644
index 00000000000..7b3be0365e9
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts
@@ -0,0 +1,14 @@
+//@target: ES6
+var [a, b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts
new file mode 100644
index 00000000000..35d05ef1f9c
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts
new file mode 100644
index 00000000000..ed93b5175d0
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts
new file mode 100644
index 00000000000..b7e763694ea
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, ...b] = new FooIterator) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts
new file mode 100644
index 00000000000..f0b9b142f40
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, ...b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts
new file mode 100644
index 00000000000..c327efa3ec2
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[a, ...b]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts
new file mode 100644
index 00000000000..21d632fd541
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[a, b]: Bar[]) { }
+fun(...new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts
new file mode 100644
index 00000000000..ba2c74681fe
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts
@@ -0,0 +1,30 @@
+//@target: ES6
+function fun(...[a, b]: [Bar, Bar][]) { }
+fun(...new FooIteratorIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class FooIteratorIterator {
+    next() {
+        return {
+            value: new FooIterator,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts
new file mode 100644
index 00000000000..90db0e5edb5
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[a, b]: Bar[]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts
new file mode 100644
index 00000000000..e6e5ad617b2
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([a, b]: Bar[]) { }
+fun(new FooIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts
new file mode 100644
index 00000000000..8513dd07649
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun([[a], b]: Bar[][]) { }
+fun(new FooArrayIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts
new file mode 100644
index 00000000000..587f1f0b056
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts
@@ -0,0 +1,14 @@
+//@target: ES6
+var [a, ...b] = new SymbolIterator;
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts
new file mode 100644
index 00000000000..b5be67b393f
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { }
+fun(...new FooArrayIterator);
+class Bar { x }
+class Foo extends Bar { y }
+class FooArrayIterator {
+    next() {
+        return {
+            value: [new Foo],
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts
new file mode 100644
index 00000000000..c8f17395d14
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+var [a, b] = { 0: "", 1: true };
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts
new file mode 100644
index 00000000000..8cf60df5597
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+var [...a] = { 0: "", 1: true };
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts
new file mode 100644
index 00000000000..91ce911b04c
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+var a: string, b: boolean;
+[a, b] = { 0: "", 1: true };
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts
new file mode 100644
index 00000000000..462b3663b8b
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+var a: string, b: boolean[];
+[a, ...b] = { 0: "", 1: true };
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts
new file mode 100644
index 00000000000..a47edb4e987
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts
new file mode 100644
index 00000000000..be295333b2e
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(new Map([["", 0], ["hello", 1]]));
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts
new file mode 100644
index 00000000000..fcf6967cd4e
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]]));
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts
new file mode 100644
index 00000000000..111abd70ac3
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", 0], ["hello", true]]));
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts
new file mode 100644
index 00000000000..403347d61e5
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { }
+takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts
new file mode 100644
index 00000000000..31656b5661f
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: Bar;
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts
new file mode 100644
index 00000000000..075ff3fd467
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts
new file mode 100644
index 00000000000..edd95be1598
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: Bar[];
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts
new file mode 100644
index 00000000000..b51d0f09d08
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string;
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts
new file mode 100644
index 00000000000..fc9395ed6a4
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string[];
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts
new file mode 100644
index 00000000000..85b2f2e54e3
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string[];
+[a, b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts
new file mode 100644
index 00000000000..dd49205d6e0
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+var a: Bar, b: string;
+[a, ...b] = new FooIterator;
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts
new file mode 100644
index 00000000000..1573c55ca8e
--- /dev/null
+++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+function fun([a, b] = new FooIterator) { }
+class Bar { x }
+class Foo extends Bar { y }
+class FooIterator {
+    next() {
+        return {
+            value: new Foo,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of57.ts b/tests/cases/conformance/es6/for-ofStatements/for-of57.ts
new file mode 100644
index 00000000000..f3c8dd97822
--- /dev/null
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of57.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+var iter: Iterable<number>;
+for (let num of iter) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts
new file mode 100644
index 00000000000..4b4f3e8cc1c
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts
@@ -0,0 +1,15 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts
new file mode 100644
index 00000000000..f8549b82b76
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts
new file mode 100644
index 00000000000..0c0108433aa
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+var iter: Iterable<number>;
+var array = [...iter];
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts
new file mode 100644
index 00000000000..9db5d010874
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts
@@ -0,0 +1,28 @@
+//@target: ES6
+var array = [...new NumberIterator, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class NumberIterator {
+    next() {
+        return {
+            value: 0,
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts
new file mode 100644
index 00000000000..174c97de7cc
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts
@@ -0,0 +1,15 @@
+//@target: ES6
+var array = [...[0, 1], ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts
new file mode 100644
index 00000000000..47c2e633702
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts
@@ -0,0 +1,15 @@
+//@target: ES6
+var array = [0, 1, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts
new file mode 100644
index 00000000000..e6a8041a961
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts
@@ -0,0 +1,15 @@
+//@target: ES6
+var array: number[] = [0, 1, ...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts
new file mode 100644
index 00000000000..7495ca6aac6
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+var array: number[] = [0, 1];
+array.concat([...new SymbolIterator]);
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts
new file mode 100644
index 00000000000..12ca478c738
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+var array: symbol[];
+array.concat([...new SymbolIterator]);
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts
new file mode 100644
index 00000000000..0e2258aa5ea
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts
@@ -0,0 +1,11 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts
new file mode 100644
index 00000000000..2b8d93c9ccb
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts
@@ -0,0 +1,14 @@
+//@target: ES6
+var array = [...new SymbolIterator];
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol()
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts
new file mode 100644
index 00000000000..85d07e56996
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(s: symbol) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts
new file mode 100644
index 00000000000..bf8ad336fbf
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo<T>(s: T[]) { return s[0] }
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts
new file mode 100644
index 00000000000..182e454cfc8
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts
@@ -0,0 +1,17 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo<T>(...s: T[]) { return s[0] }
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts
new file mode 100644
index 00000000000..a0bd1ede193
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts
@@ -0,0 +1,32 @@
+//@target: ES6
+new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts
new file mode 100644
index 00000000000..4a8fd9ff389
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts
new file mode 100644
index 00000000000..b6e8fe0c86b
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(...s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts
new file mode 100644
index 00000000000..2a73fd6f3c9
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts
@@ -0,0 +1,16 @@
+//@target: ES6
+foo(...new SymbolIterator);
+
+function foo(s1: symbol, ...s: symbol[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts
new file mode 100644
index 00000000000..c17c4156e65
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts
@@ -0,0 +1,29 @@
+//@target: ES6
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo(...s: (symbol | string)[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts
new file mode 100644
index 00000000000..2c6150f8040
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts
@@ -0,0 +1,29 @@
+//@target: ES6
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo(...s: (symbol | number)[]) { }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts
new file mode 100644
index 00000000000..56fb7936eb7
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts
@@ -0,0 +1,29 @@
+//@target: ES6
+foo(...new SymbolIterator, ...new StringIterator);
+
+function foo<T>(...s: T[]) { return s[0]; }
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts
new file mode 100644
index 00000000000..e5b969456b7
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts
@@ -0,0 +1,32 @@
+//@target: ES6
+new Foo(...new SymbolIterator, ...new StringIterator);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts
new file mode 100644
index 00000000000..470f99844ba
--- /dev/null
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts
@@ -0,0 +1,32 @@
+//@target: ES6
+new Foo(...new SymbolIterator, ...[...new StringIterator]);
+
+class Foo<T> {
+    constructor(...s: T[]) { }
+}
+
+class SymbolIterator {
+    next() {
+        return {
+            value: Symbol(),
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+
+class StringIterator {
+    next() {
+        return {
+            value: "",
+            done: false
+        };
+    }
+
+    [Symbol.iterator]() {
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/server/brace.ts b/tests/cases/fourslash/server/brace01.ts
similarity index 91%
rename from tests/cases/fourslash/server/brace.ts
rename to tests/cases/fourslash/server/brace01.ts
index fc8a71197db..916a2e0b33f 100644
--- a/tests/cases/fourslash/server/brace.ts
+++ b/tests/cases/fourslash/server/brace01.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts"/>
+/// <reference path="../fourslash.ts"/>
 
 //////curly braces
 ////module Foo [|{
diff --git a/tests/cases/fourslash/server/completions.ts b/tests/cases/fourslash/server/completions01.ts
similarity index 87%
rename from tests/cases/fourslash/server/completions.ts
rename to tests/cases/fourslash/server/completions01.ts
index 2af0393283f..a837a74849d 100644
--- a/tests/cases/fourslash/server/completions.ts
+++ b/tests/cases/fourslash/server/completions01.ts
@@ -1,4 +1,4 @@
-/// <reference path='fourslash.ts'/>
+/// <reference path="../fourslash.ts"/>
 
 ////var x: string[] = [];
 ////x.forEach(function (y) { y/*1*/
diff --git a/tests/cases/fourslash/server/completions2.ts b/tests/cases/fourslash/server/completions02.ts
similarity index 84%
rename from tests/cases/fourslash/server/completions2.ts
rename to tests/cases/fourslash/server/completions02.ts
index 3e7e77b588c..b6c39a5c723 100644
--- a/tests/cases/fourslash/server/completions2.ts
+++ b/tests/cases/fourslash/server/completions02.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts" />
+/// <reference path="../fourslash.ts"/>
 
 ////class Foo {
 ////}
diff --git a/tests/cases/fourslash/server/definition.ts b/tests/cases/fourslash/server/definition01.ts
similarity index 79%
rename from tests/cases/fourslash/server/definition.ts
rename to tests/cases/fourslash/server/definition01.ts
index f403965fe12..8bf6e73c840 100644
--- a/tests/cases/fourslash/server/definition.ts
+++ b/tests/cases/fourslash/server/definition01.ts
@@ -1,4 +1,4 @@
-/// <reference path='fourslash.ts'/>
+/// <reference path="../fourslash.ts"/>
 
 // @Filename: b.ts
 ////import n = require('a/*1*/');
diff --git a/tests/cases/fourslash/server/format.ts b/tests/cases/fourslash/server/format01.ts
similarity index 75%
rename from tests/cases/fourslash/server/format.ts
rename to tests/cases/fourslash/server/format01.ts
index 75d06eef0c2..f4541152201 100644
--- a/tests/cases/fourslash/server/format.ts
+++ b/tests/cases/fourslash/server/format01.ts
@@ -1,4 +1,4 @@
-/// <reference path='fourslash.ts' />
+/// <reference path="../fourslash.ts"/>
 
 /////**/module Default{var x= ( { } ) ;}
 
diff --git a/tests/cases/fourslash/server/formatonkey.ts b/tests/cases/fourslash/server/formatonkey01.ts
similarity index 76%
rename from tests/cases/fourslash/server/formatonkey.ts
rename to tests/cases/fourslash/server/formatonkey01.ts
index 64cd74ca858..73e817ce3b3 100644
--- a/tests/cases/fourslash/server/formatonkey.ts
+++ b/tests/cases/fourslash/server/formatonkey01.ts
@@ -1,4 +1,4 @@
-/// <reference path='fourslash.ts' />
+/// <reference path="../fourslash.ts"/>
 
 ////switch (1) {
 ////    case 1:
diff --git a/tests/cases/fourslash/server/navbar.ts b/tests/cases/fourslash/server/navbar01.ts
similarity index 96%
rename from tests/cases/fourslash/server/navbar.ts
rename to tests/cases/fourslash/server/navbar01.ts
index 67e14fe1009..82ded5e6f54 100644
--- a/tests/cases/fourslash/server/navbar.ts
+++ b/tests/cases/fourslash/server/navbar01.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts"/>
+/// <reference path="../fourslash.ts"/>
 
 ////// Interface
 ////{| "itemName": "IPoint", "kind": "interface", "parentName": "" |}interface IPoint {
diff --git a/tests/cases/fourslash/server/navto.ts b/tests/cases/fourslash/server/navto01.ts
similarity index 94%
rename from tests/cases/fourslash/server/navto.ts
rename to tests/cases/fourslash/server/navto01.ts
index ba907e985fd..1072c64494f 100644
--- a/tests/cases/fourslash/server/navto.ts
+++ b/tests/cases/fourslash/server/navto01.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts"/>
+/// <reference path="../fourslash.ts"/>
 
 /////// Module
 ////{| "itemName": "MyShapes", "kind": "module", "parentName": "", "matchKind": "substring" |}module MyShapes {
diff --git a/tests/cases/fourslash/server/occurrences01.ts b/tests/cases/fourslash/server/occurrences01.ts
new file mode 100644
index 00000000000..db2fa64f38d
--- /dev/null
+++ b/tests/cases/fourslash/server/occurrences01.ts
@@ -0,0 +1,22 @@
+/// <reference path="../fourslash.ts"/>
+
+////foo: [|switch|] (10) {
+////    [|case|] 1:
+////    [|case|] 2:
+////    [|case|] 3:
+////        [|break|];
+////        [|break|] foo;
+////        continue;
+////        continue foo;
+////}
+
+let ranges = test.ranges();
+
+for (let r of ranges) {
+    goTo.position(r.start);
+    verify.occurrencesAtPositionCount(ranges.length);
+
+    for (let range of ranges) {
+        verify.occurrencesAtPositionContains(range, /*isWriteAccess*/ false);
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/server/occurrences02.ts b/tests/cases/fourslash/server/occurrences02.ts
new file mode 100644
index 00000000000..e0d39cb92fd
--- /dev/null
+++ b/tests/cases/fourslash/server/occurrences02.ts
@@ -0,0 +1,16 @@
+/// <reference path="../fourslash.ts"/>
+
+////function [|f|](x: typeof [|f|]) {
+////    [|f|]([|f|]);
+////}
+
+let ranges = test.ranges();
+
+for (let r of ranges) {
+    goTo.position(r.start);
+    verify.occurrencesAtPositionCount(ranges.length);
+
+    for (let range of ranges) {
+        verify.occurrencesAtPositionContains(range);
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/fourslash/server/quickinfo.ts b/tests/cases/fourslash/server/quickinfo01.ts
similarity index 88%
rename from tests/cases/fourslash/server/quickinfo.ts
rename to tests/cases/fourslash/server/quickinfo01.ts
index 5292eb6c2c8..9008505e447 100644
--- a/tests/cases/fourslash/server/quickinfo.ts
+++ b/tests/cases/fourslash/server/quickinfo01.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts"/>
+/// <reference path="../fourslash.ts"/>
 
 ////interface One {
 ////    commonProperty: number;
diff --git a/tests/cases/fourslash/server/references.ts b/tests/cases/fourslash/server/references01.ts
similarity index 85%
rename from tests/cases/fourslash/server/references.ts
rename to tests/cases/fourslash/server/references01.ts
index 55b21615551..0ecbeb43de3 100644
--- a/tests/cases/fourslash/server/references.ts
+++ b/tests/cases/fourslash/server/references01.ts
@@ -1,4 +1,4 @@
-/// <reference path='fourslash.ts'/>
+/// <reference path="../fourslash.ts"/>
 
 // Global class reference.
 
diff --git a/tests/cases/fourslash/server/rename.ts b/tests/cases/fourslash/server/rename01.ts
similarity index 84%
rename from tests/cases/fourslash/server/rename.ts
rename to tests/cases/fourslash/server/rename01.ts
index 4f8b7b98cd4..2da25f87ba7 100644
--- a/tests/cases/fourslash/server/rename.ts
+++ b/tests/cases/fourslash/server/rename01.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts" />
+/// <reference path="../fourslash.ts"/>
 
 ///////<reference path="./Bar.ts" /> 
 
diff --git a/tests/cases/fourslash/server/signatureHelp.ts b/tests/cases/fourslash/server/signatureHelp01.ts
similarity index 84%
rename from tests/cases/fourslash/server/signatureHelp.ts
rename to tests/cases/fourslash/server/signatureHelp01.ts
index 294df367f07..73303ecce4c 100644
--- a/tests/cases/fourslash/server/signatureHelp.ts
+++ b/tests/cases/fourslash/server/signatureHelp01.ts
@@ -1,4 +1,4 @@
-/// <reference path="fourslash.ts"/>
+/// <reference path="../fourslash.ts"/>
 
 ////function foo(data: number) {
 ////}