diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 92eb646f480..5de2bd87e63 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -25,7 +25,7 @@ Your pull request should:
     * Tests should include reasonable permutations of the target fix/change
     * Include baseline changes with your change
     * All changed code must have 100% code coverage
-* Follow the code conventions descriped in [Coding guidlines](https://github.com/Microsoft/TypeScript/wiki/Coding-guidlines)
+* Follow the code conventions descriped in [Coding guidelines](https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines)
 * To avoid line ending issues, set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration
 
 ## Running the Tests
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 178a8d79880..ea86b2b9b04 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.
@@ -5546,7 +5582,7 @@ module ts {
                     needToCaptureLexicalThis = false;
                     while (container && container.kind === SyntaxKind.ArrowFunction) {
                         container = getSuperContainer(container, /*includeFunctions*/ true);
-                        needToCaptureLexicalThis = true;
+                        needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6;
                     }
 
                     // topmost container must be something that is directly nested in the class declaration
@@ -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/parser.ts b/src/compiler/parser.ts
index 4e23e26e6b7..5123c2124ac 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -5309,7 +5309,7 @@ module ts {
                     break;
                 }
 
-                let range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos() };
+                let range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() };
 
                 let comment = sourceText.substring(range.pos, range.end);
                 let referencePathMatchResult = getFileReferenceFromReferencePath(comment, range);
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 3a208698c25..a568667d182 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -523,6 +523,7 @@ module ts {
                     let nextChar = text.charCodeAt(pos + 1);
                     let hasTrailingNewLine = false;
                     if (nextChar === CharacterCodes.slash || nextChar === CharacterCodes.asterisk) {
+                        let kind = nextChar === CharacterCodes.slash ? SyntaxKind.SingleLineCommentTrivia : SyntaxKind.MultiLineCommentTrivia;
                         let startPos = pos;
                         pos += 2;
                         if (nextChar === CharacterCodes.slash) {
@@ -548,7 +549,7 @@ module ts {
                                 result = [];
                             }
 
-                            result.push({ pos: startPos, end: pos, hasTrailingNewLine: hasTrailingNewLine });
+                            result.push({ pos: startPos, end: pos, hasTrailingNewLine, kind });
                         }
                         continue;
                     }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 74777057963..34eb86440f4 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -985,6 +985,7 @@ module ts {
 
     export interface CommentRange extends TextRange {
         hasTrailingNewLine?: boolean;
+        kind: SyntaxKind;
     }
 
     // Source files are declarations when they are external modules.
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 4df840c3241..0826e7748aa 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -160,6 +160,14 @@ module ts {
         return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
     }
 
+    export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
+        if (nodeIsMissing(node) || !node.decorators) {
+            return getTokenPosOfNode(node, sourceFile);
+        }
+
+        return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end);        
+    }
+
     export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node): string {
         if (nodeIsMissing(node)) {
             return "";
@@ -780,6 +788,8 @@ module ts {
                         return node === (<TemplateSpan>parent).expression;
                     case SyntaxKind.ComputedPropertyName:
                         return node === (<ComputedPropertyName>parent).expression;
+                    case SyntaxKind.Decorator:
+                        return true;
                     default:
                         if (isExpression(parent)) {
                             return true;
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index 299ba52bdeb..bce4c9828fa 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -336,6 +336,9 @@ module Harness.LanguageService {
         getOccurrencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] {
             return unwrapJSONCallResult(this.shim.getOccurrencesAtPosition(fileName, position));
         }
+        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): ts.DocumentHighlights[] {
+            return unwrapJSONCallResult(this.shim.getDocumentHighlights(fileName, position, JSON.stringify(filesToSearch)));
+        }
         getNavigateToItems(searchValue: string): ts.NavigateToItem[] {
             return unwrapJSONCallResult(this.shim.getNavigateToItems(searchValue));
         }
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/lib/core.d.ts b/src/lib/core.d.ts
index 3d830ae5203..822b7ca5202 100644
--- a/src/lib/core.d.ts
+++ b/src/lib/core.d.ts
@@ -823,7 +823,7 @@ interface RegExp {
       */
     test(string: string): boolean;
 
-    /** Returns a copy of the text of the regular expression pattern. Read-only. The rgExp argument is a Regular expression object. It can be a variable name or a literal. */
+    /** Returns a copy of the text of the regular expression pattern. Read-only. The regExp argument is a Regular expression object. It can be a variable name or a literal. */
     source: string;
 
     /** Returns a Boolean value indicating the state of the global flag (g) used with a regular expression. Default is false. Read-only. */
diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index 8590e2273e0..b81a3341a6c 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -50,26 +50,21 @@ interface SymbolConstructor {
       */
     isConcatSpreadable: symbol;
 
-    /** 
-      * A Boolean value that if true indicates that an object may be used as a regular expression. 
-      */
-    isRegExp: symbol;
-
     /** 
       * A method that returns the default iterator for an object.Called by the semantics of the 
-      * for-of statement. 
+      * for-of statement.
       */
     iterator: symbol;
 
     /** 
       * A method that converts an object to a corresponding primitive value.Called by the ToPrimitive
-      * abstract operation. 
+      * abstract operation.
       */
     toPrimitive: symbol;
 
     /** 
-      * A String value that is used in the creation of the default string description of an object. 
-      * Called by the built- in method Object.prototype.toString. 
+      * A String value that is used in the creation of the default string description of an object.
+      * Called by the built-in method Object.prototype.toString.
       */
     toStringTag: symbol;
 
@@ -111,7 +106,7 @@ interface ObjectConstructor {
     getOwnPropertySymbols(o: any): symbol[];
 
     /**
-      *  Returns true if the values are the same value, false otherwise.
+      * Returns true if the values are the same value, false otherwise.
       * @param value1 The first value.
       * @param value2 The second value.
       */
@@ -598,8 +593,6 @@ interface Math {
 }
 
 interface RegExp {
-    [Symbol.isRegExp]: boolean;
-
     /** 
       * Matches a string with a regular expression, and returns an array containing the results of 
       * that search.
@@ -631,6 +624,20 @@ interface RegExp {
       */
     split(string: string, limit?: number): string[];
 
+    /**
+      * Returns a string indicating the flags of the regular expression in question. This field is read-only.
+      * The characters in this string are sequenced and concatenated in the following order:
+      *
+      *    - "g" for global
+      *    - "i" for ignoreCase
+      *    - "m" for multiline
+      *    - "u" for unicode
+      *    - "y" for sticky
+      *
+      * If no flags are set, the value is the empty string.
+      */
+    flags: string;
+
     /** 
       * Returns a Boolean value indicating the state of the sticky flag (y) used with a regular 
       * expression. Default is false. Read-only. 
diff --git a/src/server/client.ts b/src/server/client.ts
index d395d2a832c..9d71f627005 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,6 +466,29 @@ module ts.server {
         }
 
         getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
+            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,
+                };
+            });
+        }
+
+        getDocumentHighlights(fileName: string, position: number): DocumentHighlights[] {
             throw new Error("Not Implemented Yet.");
         }
 
diff --git a/src/server/protocol.d.ts b/src/server/protocol.d.ts
index 1d685be5d3a..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
diff --git a/src/server/session.ts b/src/server/session.ts
index 560f5869c08..09373d6bf96 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -89,6 +89,7 @@ module ts.server {
         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";
@@ -117,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);
             });
         }
@@ -262,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) {
@@ -284,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) {
@@ -352,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);
@@ -378,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);
@@ -399,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) {
@@ -430,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) {
@@ -457,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);
@@ -530,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 = "";
             }
@@ -556,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) {
@@ -576,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,
@@ -601,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);
@@ -616,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) {
@@ -635,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);
@@ -648,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);
 
@@ -658,7 +688,7 @@ module ts.server {
             }
         }
 
-        closeClientFile(fileName: string) {
+        closeClientFile({ file: fileName }: protocol.FileRequestArgs) {
             var file = ts.normalizePath(fileName);
             this.projectService.closeClientFile(file);
         }
@@ -682,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) {
@@ -698,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) {
@@ -737,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);
@@ -779,109 +809,91 @@ module ts.server {
                         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/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts
index 6a5ed25459e..0f5f49f3d8f 100644
--- a/src/services/formatting/formatting.ts
+++ b/src/services/formatting/formatting.ts
@@ -328,8 +328,13 @@ module ts.formatting {
 
         if (formattingScanner.isOnToken()) {
             let startLine = sourceFile.getLineAndCharacterOfPosition(enclosingNode.getStart(sourceFile)).line;
+            let undecoratedStartLine = startLine;
+            if (enclosingNode.decorators) {
+                undecoratedStartLine = sourceFile.getLineAndCharacterOfPosition(getNonDecoratorTokenPosOfNode(enclosingNode, sourceFile)).line;
+            }
+
             let delta = getOwnOrInheritedDelta(enclosingNode, options, sourceFile);
-            processNode(enclosingNode, enclosingNode, startLine, initialIndentation, delta);
+            processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta);
         }
 
         formattingScanner.close();
@@ -500,7 +505,7 @@ module ts.formatting {
             }
         }
 
-        function processNode(node: Node, contextNode: Node, nodeStartLine: number, indentation: number, delta: number) {
+        function processNode(node: Node, contextNode: Node, nodeStartLine: number, undecoratedNodeStartLine: number, indentation: number, delta: number) {
             if (!rangeOverlapsWithStartEnd(originalRange, node.getStart(sourceFile), node.getEnd())) {
                 return;
             }
@@ -526,7 +531,7 @@ module ts.formatting {
             forEachChild(
                 node,
                 child => {
-                    processChildNode(child, /*inheritedIndentation*/ Constants.Unknown, node, nodeDynamicIndentation, nodeStartLine, /*isListElement*/ false)
+                    processChildNode(child, /*inheritedIndentation*/ Constants.Unknown, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, /*isListElement*/ false)
                 },
                 (nodes: NodeArray<Node>) => {
                     processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation);
@@ -547,11 +552,17 @@ module ts.formatting {
                 parent: Node,
                 parentDynamicIndentation: DynamicIndentation,
                 parentStartLine: number,
+                undecoratedParentStartLine: number,
                 isListItem: boolean): number {
 
                 let childStartPos = child.getStart(sourceFile);
 
-                let childStart = sourceFile.getLineAndCharacterOfPosition(childStartPos);
+                let childStartLine = sourceFile.getLineAndCharacterOfPosition(childStartPos).line;
+
+                let undecoratedChildStartLine = childStartLine;
+                if (child.decorators) {
+                    undecoratedChildStartLine = sourceFile.getLineAndCharacterOfPosition(getNonDecoratorTokenPosOfNode(child, sourceFile)).line;
+                }
 
                 // if child is a list item - try to get its indentation
                 let childIndentationAmount = Constants.Unknown;
@@ -594,9 +605,10 @@ module ts.formatting {
                     return inheritedIndentation;
                 }
 
-                let childIndentation = computeIndentation(child, childStart.line, childIndentationAmount, node, parentDynamicIndentation, parentStartLine);
+                let effectiveParentStartLine = child.kind === SyntaxKind.Decorator ? childStartLine : undecoratedParentStartLine;
+                let childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine);
 
-                processNode(child, childContextNode, childStart.line, childIndentation.indentation, childIndentation.delta);
+                processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta);
 
                 childContextNode = node;
 
@@ -640,7 +652,7 @@ module ts.formatting {
 
                 let inheritedIndentation = Constants.Unknown;
                 for (let child of nodes) {
-                    inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, /*isListElement*/ true)
+                    inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, /*isListElement*/ true)
                 }
 
                 if (listEndToken !== SyntaxKind.Unknown) {
diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts
index 7d3509ef495..f5cb8cb4e64 100644
--- a/src/services/formatting/rules.ts
+++ b/src/services/formatting/rules.ts
@@ -208,6 +208,11 @@ module ts.formatting {
         public SpaceAfterAnonymousFunctionKeyword: Rule;
         public NoSpaceAfterAnonymousFunctionKeyword: Rule;
 
+        // Insert space after @ in decorator
+        public SpaceBeforeAt: Rule;
+        public NoSpaceAfterAt: Rule;
+        public SpaceAfterDecorator: Rule;
+
         constructor() {
             ///
             /// Common Rules
@@ -344,6 +349,11 @@ module ts.formatting {
             // Remove spaces in empty interface literals. e.g.: x: {}
             this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new Rule(RuleDescriptor.create1(SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectTypeContext), RuleAction.Delete));
 
+            // decorators
+            this.SpaceBeforeAt = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.AtToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space));
+            this.NoSpaceAfterAt = new Rule(RuleDescriptor.create3(SyntaxKind.AtToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete));
+            this.SpaceAfterDecorator = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.ExportKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.ClassKeyword, SyntaxKind.StaticKeyword, SyntaxKind.PublicKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword, SyntaxKind.OpenBracketToken, SyntaxKind.AsteriskToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsEndOfDecoratorContextOnSameLine), RuleAction.Space));
+
             // These rules are higher in priority than user-configurable rules.
             this.HighPriorityCommonRules =
             [
@@ -381,7 +391,10 @@ module ts.formatting {
                 this.NoSpaceBetweenCloseParenAndAngularBracket,
                 this.NoSpaceAfterOpenAngularBracket,
                 this.NoSpaceBeforeCloseAngularBracket,
-                this.NoSpaceAfterCloseAngularBracket
+                this.NoSpaceAfterCloseAngularBracket,
+                this.SpaceBeforeAt,
+                this.NoSpaceAfterAt,
+                this.SpaceAfterDecorator,
             ];
 
             // These rules are lower in priority than user-configurable rules.
@@ -649,6 +662,20 @@ module ts.formatting {
             return context.TokensAreOnSameLine();
         }
 
+        static IsEndOfDecoratorContextOnSameLine(context: FormattingContext): boolean {
+            return context.TokensAreOnSameLine() &&
+                context.contextNode.decorators &&
+                Rules.NodeIsInDecoratorContext(context.currentTokenParent) &&
+                !Rules.NodeIsInDecoratorContext(context.nextTokenParent);
+        }
+
+        static NodeIsInDecoratorContext(node: Node): boolean {
+            while (isExpression(node)) {
+                node = node.parent;
+            }
+            return node.kind === SyntaxKind.Decorator;
+        }
+
         static IsStartOfVariableDeclarationList(context: FormattingContext): boolean {
             return context.currentTokenParent.kind === SyntaxKind.VariableDeclarationList && 
                 context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos;
diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts
index 4c9dcedc7a4..13ed3d3ea69 100644
--- a/src/services/outliningElementsCollector.ts
+++ b/src/services/outliningElementsCollector.ts
@@ -1,18 +1,3 @@
-//
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-// 
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
 module ts {
     export module OutliningElementsCollector {
         export function collectElements(sourceFile: SourceFile): OutliningSpan[] {
@@ -31,6 +16,66 @@ module ts {
                 }
             }
 
+            function addOutliningSpanComments(commentSpan: CommentRange, autoCollapse: boolean) {
+                if (commentSpan) {
+                    let span: OutliningSpan = {
+                        textSpan: createTextSpanFromBounds(commentSpan.pos, commentSpan.end),
+                        hintSpan: createTextSpanFromBounds(commentSpan.pos, commentSpan.end),
+                        bannerText: collapseText,
+                        autoCollapse: autoCollapse
+                    };
+                    elements.push(span);
+                }
+            }
+
+            function addOutliningForLeadingCommentsForNode(n: Node) {
+                let comments = ts.getLeadingCommentRangesOfNode(n, sourceFile);
+
+                if (comments) {
+                    let firstSingleLineCommentStart = -1;
+                    let lastSingleLineCommentEnd = -1;
+                    let isFirstSingleLineComment = true;
+                    let singleLineCommentCount = 0;
+
+                    for (let currentComment of comments) {
+
+                        // For single line comments, combine consecutive ones (2 or more) into
+                        // a single span from the start of the first till the end of the last
+                        if (currentComment.kind === SyntaxKind.SingleLineCommentTrivia) {
+                            if (isFirstSingleLineComment) {
+                                firstSingleLineCommentStart = currentComment.pos;
+                            }
+                            isFirstSingleLineComment = false;
+                            lastSingleLineCommentEnd = currentComment.end;
+                            singleLineCommentCount++;
+                        }
+                        else if (currentComment.kind === SyntaxKind.MultiLineCommentTrivia) {
+                            combineAndAddMultipleSingleLineComments(singleLineCommentCount, firstSingleLineCommentStart, lastSingleLineCommentEnd);
+                            addOutliningSpanComments(currentComment, /*autoCollapse*/ false);
+
+                            singleLineCommentCount = 0;
+                            lastSingleLineCommentEnd = -1;
+                            isFirstSingleLineComment = true;
+                        }
+                    }
+
+                    combineAndAddMultipleSingleLineComments(singleLineCommentCount, firstSingleLineCommentStart, lastSingleLineCommentEnd);
+                }
+            }
+
+            function combineAndAddMultipleSingleLineComments(count: number, start: number, end: number) {                
+                // Only outline spans of two or more consecutive single line comments
+                if (count > 1) {
+                    let multipleSingleLineComments = {
+                        pos: start,
+                        end: end,
+                        kind: SyntaxKind.SingleLineCommentTrivia
+                    }
+
+                    addOutliningSpanComments(multipleSingleLineComments, /*autoCollapse*/ false);
+                }
+            }
+
             function autoCollapse(node: Node) {
                 return isFunctionBlock(node) && node.parent.kind !== SyntaxKind.ArrowFunction;
             }
@@ -41,6 +86,11 @@ module ts {
                 if (depth > maxDepth) {
                     return;
                 }
+
+                if (isDeclaration(n)) {
+                    addOutliningForLeadingCommentsForNode(n);
+                }
+
                 switch (n.kind) {
                     case SyntaxKind.Block:
                         if (!isFunctionBlock(n)) {
@@ -93,7 +143,7 @@ module ts {
                             });
                             break;
                         }
-                        // Fallthrough.
+                    // Fallthrough.
 
                     case SyntaxKind.ModuleBlock: {
                         let openBrace = findChildOfKind(n, SyntaxKind.OpenBraceToken, sourceFile);
diff --git a/src/services/services.ts b/src/services/services.ts
index 86c323f24bf..19fcb46552c 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -944,8 +944,11 @@ module ts {
 
         getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
         getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
-        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
         findReferences(fileName: string, position: number): ReferencedSymbol[];
+        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[];
+
+        /** @deprecated */
+        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
 
         getNavigateToItems(searchValue: string, maxResultCount?: number): NavigateToItem[];
         getNavigationBarItems(fileName: string): NavigationBarItem[];
@@ -1011,6 +1014,23 @@ module ts {
         isWriteAccess: boolean;
     }
 
+    export interface DocumentHighlights {
+        fileName: string;
+        highlightSpans: HighlightSpan[];
+    }
+
+    export module HighlightSpanKind {
+        export const none = "none";
+        export const definition = "definition";
+        export const reference = "reference";
+        export const writtenReference = "writtenReference";
+    } 
+
+    export interface HighlightSpan {
+        textSpan: TextSpan;
+        kind: string;
+    }
+
     export interface NavigateToItem {
         name: string;
         kind: string;
@@ -1315,92 +1335,92 @@ module ts {
     }
 
     // TODO: move these to enums
-    export class ScriptElementKind {
-        static unknown = "";
-        static warning = "warning";
+    export module ScriptElementKind {
+        export const unknown = "";
+        export const warning = "warning";
 
         // predefined type (void) or keyword (class)
-        static keyword = "keyword";
+        export const keyword = "keyword";
 
         // top level script node
-        static scriptElement = "script";
+        export const scriptElement = "script";
 
         // module foo {}
-        static moduleElement = "module";
+        export const moduleElement = "module";
 
         // class X {}
-        static classElement = "class";
+        export const classElement = "class";
 
         // interface Y {}
-        static interfaceElement = "interface";
+        export const interfaceElement = "interface";
 
         // type T = ...
-        static typeElement = "type";
+        export const typeElement = "type";
 
         // enum E
-        static enumElement = "enum";
+        export const enumElement = "enum";
 
         // Inside module and script only
         // let v = ..
-        static variableElement = "var";
+        export const variableElement = "var";
 
         // Inside function
-        static localVariableElement = "local var";
+        export const localVariableElement = "local var";
 
         // Inside module and script only
         // function f() { }
-        static functionElement = "function";
+        export const functionElement = "function";
 
         // Inside function
-        static localFunctionElement = "local function";
+        export const localFunctionElement = "local function";
 
         // class X { [public|private]* foo() {} }
-        static memberFunctionElement = "method";
+        export const memberFunctionElement = "method";
 
         // class X { [public|private]* [get|set] foo:number; }
-        static memberGetAccessorElement = "getter";
-        static memberSetAccessorElement = "setter";
+        export const memberGetAccessorElement = "getter";
+        export const memberSetAccessorElement = "setter";
 
         // class X { [public|private]* foo:number; }
         // interface Y { foo:number; }
-        static memberVariableElement = "property";
+        export const memberVariableElement = "property";
 
         // class X { constructor() { } }
-        static constructorImplementationElement = "constructor";
+        export const constructorImplementationElement = "constructor";
 
         // interface Y { ():number; }
-        static callSignatureElement = "call";
+        export const callSignatureElement = "call";
 
         // interface Y { []:number; }
-        static indexSignatureElement = "index";
+        export const indexSignatureElement = "index";
 
         // interface Y { new():Y; }
-        static constructSignatureElement = "construct";
+        export const constructSignatureElement = "construct";
 
         // function foo(*Y*: string)
-        static parameterElement = "parameter";
+        export const parameterElement = "parameter";
 
-        static typeParameterElement = "type parameter";
+        export const typeParameterElement = "type parameter";
 
-        static primitiveType = "primitive type";
+        export const primitiveType = "primitive type";
 
-        static label = "label";
+        export const label = "label";
 
-        static alias = "alias";
+        export const alias = "alias";
 
-        static constElement = "const";
+        export const constElement = "const";
 
-        static letElement = "let";
+        export const letElement = "let";
     }
 
-    export class ScriptElementKindModifier {
-        static none = "";
-        static publicMemberModifier = "public";
-        static privateMemberModifier = "private";
-        static protectedMemberModifier = "protected";
-        static exportedModifier = "export";
-        static ambientModifier = "declare";
-        static staticModifier = "static";
+    export module ScriptElementKindModifier {
+        export const none = "";
+        export const publicMemberModifier = "public";
+        export const privateMemberModifier = "private";
+        export const protectedMemberModifier = "protected";
+        export const exportedModifier = "export";
+        export const ambientModifier = "declare";
+        export const staticModifier = "static";
     }
 
     export class ClassificationTypeNames {
@@ -3961,20 +3981,19 @@ module ts {
             if (results) {
                 let sourceFile = getCanonicalFileName(normalizeSlashes(fileName));
 
-                // ensure the results are in the file we're interested in
-                results.forEach((value) => {
-                    let targetFile = getCanonicalFileName(normalizeSlashes(value.fileName));
-                    Debug.assert(sourceFile == targetFile, `Unexpected file in results. Found results in ${targetFile} expected only results in ${sourceFile}.`);
-                });
+                // Get occurrences only supports reporting occurrences for the file queried.  So 
+                // filter down to that list.
+                results = filter(results, r => r.fileName === fileName);
             }
 
             return results;
         }
 
-        /// References and Occurrences
-        function getOccurrencesAtPositionCore(fileName: string, position: number): ReferenceEntry[] {
+        function getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[] {
             synchronizeHostData();
 
+            filesToSearch = map(filesToSearch, normalizeSlashes);
+            let sourceFilesToSearch = filter(program.getSourceFiles(), f => contains(filesToSearch, f.fileName));
             let sourceFile = getValidSourceFile(fileName);
 
             let node = getTouchingWord(sourceFile, position);
@@ -3982,549 +4001,642 @@ module ts {
                 return undefined;
             }
 
-            if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisKeyword || node.kind === SyntaxKind.SuperKeyword ||
-                isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) {
-                return convertReferences(getReferencesForNode(node, [sourceFile], /*searchOnlyInCurrentFile*/ true, /*findInStrings:*/ false, /*findInComments:*/ false));
+            return getSemanticDocumentHighlights(node) || getSyntacticDocumentHighlights(node);
+
+            function getHighlightSpanForNode(node: Node): HighlightSpan {
+                let start = node.getStart();
+                let end = node.getEnd();
+
+                return {
+                    fileName: sourceFile.fileName,
+                    textSpan: createTextSpanFromBounds(start, end),
+                    kind: HighlightSpanKind.none
+                };
             }
 
-            switch (node.kind) {
-                case SyntaxKind.IfKeyword:
-                case SyntaxKind.ElseKeyword:
-                    if (hasKind(node.parent, SyntaxKind.IfStatement)) {
-                        return getIfElseOccurrences(<IfStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.ReturnKeyword:
-                    if (hasKind(node.parent, SyntaxKind.ReturnStatement)) {
-                        return getReturnOccurrences(<ReturnStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.ThrowKeyword:
-                    if (hasKind(node.parent, SyntaxKind.ThrowStatement)) {
-                        return getThrowOccurrences(<ThrowStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.CatchKeyword:
-                    if (hasKind(parent(parent(node)), SyntaxKind.TryStatement)) {
-                        return getTryCatchFinallyOccurrences(<TryStatement>node.parent.parent);
-                    }
-                    break;
-                case SyntaxKind.TryKeyword:
-                case SyntaxKind.FinallyKeyword:
-                    if (hasKind(parent(node), SyntaxKind.TryStatement)) {
-                        return getTryCatchFinallyOccurrences(<TryStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.SwitchKeyword:
-                    if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
-                        return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.CaseKeyword:
-                case SyntaxKind.DefaultKeyword:
-                    if (hasKind(parent(parent(parent(node))), SyntaxKind.SwitchStatement)) {
-                        return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent.parent.parent);
-                    }
-                    break;
-                case SyntaxKind.BreakKeyword:
-                case SyntaxKind.ContinueKeyword:
-                    if (hasKind(node.parent, SyntaxKind.BreakStatement) || hasKind(node.parent, SyntaxKind.ContinueStatement)) {
-                        return getBreakOrContinueStatementOccurences(<BreakOrContinueStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.ForKeyword:
-                    if (hasKind(node.parent, SyntaxKind.ForStatement) ||
-                        hasKind(node.parent, SyntaxKind.ForInStatement) ||
-                        hasKind(node.parent, SyntaxKind.ForOfStatement)) {
-                        return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.WhileKeyword:
-                case SyntaxKind.DoKeyword:
-                    if (hasKind(node.parent, SyntaxKind.WhileStatement) || hasKind(node.parent, SyntaxKind.DoStatement)) {
-                        return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
-                    }
-                    break;
-                case SyntaxKind.ConstructorKeyword:
-                    if (hasKind(node.parent, SyntaxKind.Constructor)) {
-                        return getConstructorOccurrences(<ConstructorDeclaration>node.parent);
-                    }
-                    break;
-                case SyntaxKind.GetKeyword:
-                case SyntaxKind.SetKeyword:
-                    if (hasKind(node.parent, SyntaxKind.GetAccessor) || hasKind(node.parent, SyntaxKind.SetAccessor)) {
-                        return getGetAndSetOccurrences(<AccessorDeclaration>node.parent);
-                    }
-                default:
-                    if (isModifier(node.kind) && node.parent &&
-                        (isDeclaration(node.parent) || node.parent.kind === SyntaxKind.VariableStatement)) {
-                        return getModifierOccurrences(node.kind, node.parent);
-                    }
-            }
+            function getSemanticDocumentHighlights(node: Node): DocumentHighlights[] {
+                if (node.kind === SyntaxKind.Identifier ||
+                    node.kind === SyntaxKind.ThisKeyword ||
+                    node.kind === SyntaxKind.SuperKeyword ||
+                    isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
+                    isNameOfExternalModuleImportOrDeclaration(node)) {
 
-            return undefined;
-
-            function getIfElseOccurrences(ifStatement: IfStatement): ReferenceEntry[] {
-                let keywords: Node[] = [];
-
-                // Traverse upwards through all parent if-statements linked by their else-branches.
-                while (hasKind(ifStatement.parent, SyntaxKind.IfStatement) && (<IfStatement>ifStatement.parent).elseStatement === ifStatement) {
-                    ifStatement = <IfStatement>ifStatement.parent;
+                    let referencedSymbols = getReferencedSymbolsForNodes(node, sourceFilesToSearch, /*findInStrings:*/ false, /*findInComments:*/ false);
+                    return convertReferencedSymbols(referencedSymbols);
                 }
 
-                // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
-                while (ifStatement) {
-                    let children = ifStatement.getChildren();
-                    pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
+                return undefined;
 
-                    // Generally the 'else' keyword is second-to-last, so we traverse backwards.
-                    for (let i = children.length - 1; i >= 0; i--) {
-                        if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
-                            break;
+                function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
+                    if (!referencedSymbols) {
+                        return undefined;
+                    }
+
+                    let fileNameToDocumentHighlights: Map<DocumentHighlights> = {};
+                    let result: DocumentHighlights[] = [];
+                    for (let referencedSymbol of referencedSymbols) {
+                        for (let referenceEntry of referencedSymbol.references) {
+                            let fileName = referenceEntry.fileName;
+                            let documentHighlights = getProperty(fileNameToDocumentHighlights, fileName);
+                            if (!documentHighlights) {
+                                documentHighlights = { fileName, highlightSpans: [] };
+
+                                fileNameToDocumentHighlights[fileName] = documentHighlights;
+                                result.push(documentHighlights);
+                            }
+
+                            documentHighlights.highlightSpans.push({
+                                textSpan: referenceEntry.textSpan,
+                                kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
+                            });
                         }
                     }
 
-                    if (!hasKind(ifStatement.elseStatement, SyntaxKind.IfStatement)) {
-                        break
-                    }
+                    return result;
+                }
+            }
 
-                    ifStatement = <IfStatement>ifStatement.elseStatement;
+            function getSyntacticDocumentHighlights(node: Node): DocumentHighlights[] {
+                let fileName = sourceFile.fileName;
+
+                var highlightSpans = getHighlightSpans(node);
+                if (!highlightSpans || highlightSpans.length === 0) {
+                    return undefined;
                 }
 
-                let result: ReferenceEntry[] = [];
+                return [{ fileName, highlightSpans }];
 
-                // We'd like to highlight else/ifs together if they are only separated by whitespace
-                // (i.e. the keywords are separated by no comments, no newlines).
-                for (let i = 0; i < keywords.length; i++) {
-                    if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
-                        let elseKeyword = keywords[i];
-                        let ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+                // returns true if 'node' is defined and has a matching 'kind'.
+                function hasKind(node: Node, kind: SyntaxKind) {
+                    return node !== undefined && node.kind === kind;
+                }
 
-                        let shouldHighlightNextKeyword = true;
+                // Null-propagating 'parent' function.
+                function parent(node: Node): Node {
+                    return node && node.parent;
+                }
 
-                        // Avoid recalculating getStart() by iterating backwards.
-                        for (let j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
-                            if (!isWhiteSpace(sourceFile.text.charCodeAt(j))) {
-                                shouldHighlightNextKeyword = false;
+                function getHighlightSpans(node: Node): HighlightSpan[] {
+                    if (node) {
+                        switch (node.kind) {
+                            case SyntaxKind.IfKeyword:
+                            case SyntaxKind.ElseKeyword:
+                                if (hasKind(node.parent, SyntaxKind.IfStatement)) {
+                                    return getIfElseOccurrences(<IfStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.ReturnKeyword:
+                                if (hasKind(node.parent, SyntaxKind.ReturnStatement)) {
+                                    return getReturnOccurrences(<ReturnStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.ThrowKeyword:
+                                if (hasKind(node.parent, SyntaxKind.ThrowStatement)) {
+                                    return getThrowOccurrences(<ThrowStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.CatchKeyword:
+                                if (hasKind(parent(parent(node)), SyntaxKind.TryStatement)) {
+                                    return getTryCatchFinallyOccurrences(<TryStatement>node.parent.parent);
+                                }
+                                break;
+                            case SyntaxKind.TryKeyword:
+                            case SyntaxKind.FinallyKeyword:
+                                if (hasKind(parent(node), SyntaxKind.TryStatement)) {
+                                    return getTryCatchFinallyOccurrences(<TryStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.SwitchKeyword:
+                                if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
+                                    return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.CaseKeyword:
+                            case SyntaxKind.DefaultKeyword:
+                                if (hasKind(parent(parent(parent(node))), SyntaxKind.SwitchStatement)) {
+                                    return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent.parent.parent);
+                                }
+                                break;
+                            case SyntaxKind.BreakKeyword:
+                            case SyntaxKind.ContinueKeyword:
+                                if (hasKind(node.parent, SyntaxKind.BreakStatement) || hasKind(node.parent, SyntaxKind.ContinueStatement)) {
+                                    return getBreakOrContinueStatementOccurences(<BreakOrContinueStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.ForKeyword:
+                                if (hasKind(node.parent, SyntaxKind.ForStatement) ||
+                                    hasKind(node.parent, SyntaxKind.ForInStatement) ||
+                                    hasKind(node.parent, SyntaxKind.ForOfStatement)) {
+                                    return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.WhileKeyword:
+                            case SyntaxKind.DoKeyword:
+                                if (hasKind(node.parent, SyntaxKind.WhileStatement) || hasKind(node.parent, SyntaxKind.DoStatement)) {
+                                    return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.ConstructorKeyword:
+                                if (hasKind(node.parent, SyntaxKind.Constructor)) {
+                                    return getConstructorOccurrences(<ConstructorDeclaration>node.parent);
+                                }
+                                break;
+                            case SyntaxKind.GetKeyword:
+                            case SyntaxKind.SetKeyword:
+                                if (hasKind(node.parent, SyntaxKind.GetAccessor) || hasKind(node.parent, SyntaxKind.SetAccessor)) {
+                                    return getGetAndSetOccurrences(<AccessorDeclaration>node.parent);
+                                }
+                            default:
+                                if (isModifier(node.kind) && node.parent &&
+                                    (isDeclaration(node.parent) || node.parent.kind === SyntaxKind.VariableStatement)) {
+                                    return getModifierOccurrences(node.kind, node.parent);
+                                }
+                        }
+                    }
+
+                    return undefined;
+                }
+
+                /**
+                 * Aggregates all throw-statements within this node *without* crossing
+                 * into function boundaries and try-blocks with catch-clauses.
+                 */
+                function aggregateOwnedThrowStatements(node: Node): ThrowStatement[] {
+                    let statementAccumulator: ThrowStatement[] = []
+                    aggregate(node);
+                    return statementAccumulator;
+
+                    function aggregate(node: Node): void {
+                        if (node.kind === SyntaxKind.ThrowStatement) {
+                            statementAccumulator.push(<ThrowStatement>node);
+                        }
+                        else if (node.kind === SyntaxKind.TryStatement) {
+                            let tryStatement = <TryStatement>node;
+
+                            if (tryStatement.catchClause) {
+                                aggregate(tryStatement.catchClause);
+                            }
+                            else {
+                                // Exceptions thrown within a try block lacking a catch clause
+                                // are "owned" in the current context.
+                                aggregate(tryStatement.tryBlock);
+                            }
+
+                            if (tryStatement.finallyBlock) {
+                                aggregate(tryStatement.finallyBlock);
+                            }
+                        }
+                        // Do not cross function boundaries.
+                        else if (!isFunctionLike(node)) {
+                            forEachChild(node, aggregate);
+                        }
+                    };
+                }
+
+                /**
+                 * For lack of a better name, this function takes a throw statement and returns the
+                 * nearest ancestor that is a try-block (whose try statement has a catch clause),
+                 * function-block, or source file.
+                 */
+                function getThrowStatementOwner(throwStatement: ThrowStatement): Node {
+                    let child: Node = throwStatement;
+
+                    while (child.parent) {
+                        let parent = child.parent;
+
+                        if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
+                            return parent;
+                        }
+                    
+                        // A throw-statement is only owned by a try-statement if the try-statement has
+                        // a catch clause, and if the throw-statement occurs within the try block.
+                        if (parent.kind === SyntaxKind.TryStatement) {
+                            let tryStatement = <TryStatement>parent;
+
+                            if (tryStatement.tryBlock === child && tryStatement.catchClause) {
+                                return child;
+                            }
+                        }
+
+                        child = parent;
+                    }
+
+                    return undefined;
+                }
+
+                function aggregateAllBreakAndContinueStatements(node: Node): BreakOrContinueStatement[] {
+                    let statementAccumulator: BreakOrContinueStatement[] = []
+                    aggregate(node);
+                    return statementAccumulator;
+
+                    function aggregate(node: Node): void {
+                        if (node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement) {
+                            statementAccumulator.push(<BreakOrContinueStatement>node);
+                        }
+                        // Do not cross function boundaries.
+                        else if (!isFunctionLike(node)) {
+                            forEachChild(node, aggregate);
+                        }
+                    };
+                }
+
+                function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
+                    let actualOwner = getBreakOrContinueOwner(statement);
+
+                    return actualOwner && actualOwner === owner;
+                }
+
+                function getBreakOrContinueOwner(statement: BreakOrContinueStatement): Node {
+                    for (let node = statement.parent; node; node = node.parent) {
+                        switch (node.kind) {
+                            case SyntaxKind.SwitchStatement:
+                                if (statement.kind === SyntaxKind.ContinueStatement) {
+                                    continue;
+                                }
+                            // Fall through.
+                            case SyntaxKind.ForStatement:
+                            case SyntaxKind.ForInStatement:
+                            case SyntaxKind.ForOfStatement:
+                            case SyntaxKind.WhileStatement:
+                            case SyntaxKind.DoStatement:
+                                if (!statement.label || isLabeledBy(node, statement.label.text)) {
+                                    return node;
+                                }
+                                break;
+                            default:
+                                // Don't cross function boundaries.
+                                if (isFunctionLike(node)) {
+                                    return undefined;
+                                }
+                                break;
+                        }
+                    }
+
+                    return undefined;
+                }
+
+                function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): HighlightSpan[] {
+                    let container = declaration.parent;
+
+                    // Make sure we only highlight the keyword when it makes sense to do so.
+                    if (isAccessibilityModifier(modifier)) {
+                        if (!(container.kind === SyntaxKind.ClassDeclaration ||
+                            (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) {
+                            return undefined;
+                        }
+                    }
+                    else if (modifier === SyntaxKind.StaticKeyword) {
+                        if (container.kind !== SyntaxKind.ClassDeclaration) {
+                            return undefined;
+                        }
+                    }
+                    else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) {
+                        if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) {
+                            return undefined;
+                        }
+                    }
+                    else { 
+                        // unsupported modifier
+                        return undefined;
+                    }
+
+                    let keywords: Node[] = [];
+                    let modifierFlag: NodeFlags = getFlagFromModifier(modifier);
+
+                    let nodes: Node[];
+                    switch (container.kind) {
+                        case SyntaxKind.ModuleBlock:
+                        case SyntaxKind.SourceFile:
+                            nodes = (<Block>container).statements;
+                            break;
+                        case SyntaxKind.Constructor:
+                            nodes = (<Node[]>(<ConstructorDeclaration>container).parameters).concat(
+                                (<ClassDeclaration>container.parent).members);
+                            break;
+                        case SyntaxKind.ClassDeclaration:
+                            nodes = (<ClassDeclaration>container).members;
+
+                            // If we're an accessibility modifier, we're in an instance member and should search
+                            // the constructor's parameter list for instance members as well.
+                            if (modifierFlag & NodeFlags.AccessibilityModifier) {
+                                let constructor = forEach((<ClassDeclaration>container).members, member => {
+                                    return member.kind === SyntaxKind.Constructor && <ConstructorDeclaration>member;
+                                });
+
+                                if (constructor) {
+                                    nodes = nodes.concat(constructor.parameters);
+                                }
+                            }
+                            break;
+                        default:
+                            Debug.fail("Invalid container kind.")
+                    }
+
+                    forEach(nodes, node => {
+                        if (node.modifiers && node.flags & modifierFlag) {
+                            forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier));
+                        }
+                    });
+
+                    return map(keywords, getHighlightSpanForNode);
+
+                    function getFlagFromModifier(modifier: SyntaxKind) {
+                        switch (modifier) {
+                            case SyntaxKind.PublicKeyword:
+                                return NodeFlags.Public;
+                            case SyntaxKind.PrivateKeyword:
+                                return NodeFlags.Private;
+                            case SyntaxKind.ProtectedKeyword:
+                                return NodeFlags.Protected;
+                            case SyntaxKind.StaticKeyword:
+                                return NodeFlags.Static;
+                            case SyntaxKind.ExportKeyword:
+                                return NodeFlags.Export;
+                            case SyntaxKind.DeclareKeyword:
+                                return NodeFlags.Ambient;
+                            default:
+                                Debug.fail();
+                        }
+                    }
+                }
+
+                function pushKeywordIf(keywordList: Node[], token: Node, ...expected: SyntaxKind[]): boolean {
+                    if (token && contains(expected, token.kind)) {
+                        keywordList.push(token);
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                function getGetAndSetOccurrences(accessorDeclaration: AccessorDeclaration): HighlightSpan[] {
+                    let keywords: Node[] = [];
+
+                    tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.GetAccessor);
+                    tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.SetAccessor);
+
+                    return map(keywords, getHighlightSpanForNode);
+
+                    function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
+                        let accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
+
+                        if (accessor) {
+                            forEach(accessor.getChildren(), child => pushKeywordIf(keywords, child, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword));
+                        }
+                    }
+                }
+
+                function getConstructorOccurrences(constructorDeclaration: ConstructorDeclaration): HighlightSpan[] {
+                    let declarations = constructorDeclaration.symbol.getDeclarations()
+
+                    let keywords: Node[] = [];
+
+                    forEach(declarations, declaration => {
+                        forEach(declaration.getChildren(), token => {
+                            return pushKeywordIf(keywords, token, SyntaxKind.ConstructorKeyword);
+                        });
+                    });
+
+                    return map(keywords, getHighlightSpanForNode);
+                }
+
+                function getLoopBreakContinueOccurrences(loopNode: IterationStatement): HighlightSpan[] {
+                    let keywords: Node[] = [];
+
+                    if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
+                        // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
+                        if (loopNode.kind === SyntaxKind.DoStatement) {
+                            let loopTokens = loopNode.getChildren();
+
+                            for (let i = loopTokens.length - 1; i >= 0; i--) {
+                                if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    let breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
+
+                    forEach(breaksAndContinues, statement => {
+                        if (ownsBreakOrContinueStatement(loopNode, statement)) {
+                            pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
+                        }
+                    });
+
+                    return map(keywords, getHighlightSpanForNode);
+                }
+
+                function getBreakOrContinueStatementOccurences(breakOrContinueStatement: BreakOrContinueStatement): HighlightSpan[] {
+                    let owner = getBreakOrContinueOwner(breakOrContinueStatement);
+
+                    if (owner) {
+                        switch (owner.kind) {
+                            case SyntaxKind.ForStatement:
+                            case SyntaxKind.ForInStatement:
+                            case SyntaxKind.ForOfStatement:
+                            case SyntaxKind.DoStatement:
+                            case SyntaxKind.WhileStatement:
+                                return getLoopBreakContinueOccurrences(<IterationStatement>owner)
+                            case SyntaxKind.SwitchStatement:
+                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>owner);
+
+                        }
+                    }
+
+                    return undefined;
+                }
+
+                function getSwitchCaseDefaultOccurrences(switchStatement: SwitchStatement): HighlightSpan[] {
+                    let keywords: Node[] = [];
+
+                    pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
+
+                    // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
+                    forEach(switchStatement.caseBlock.clauses, clause => {
+                        pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
+
+                        let breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
+
+                        forEach(breaksAndContinues, statement => {
+                            if (ownsBreakOrContinueStatement(switchStatement, statement)) {
+                                pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
+                            }
+                        });
+                    });
+
+                    return map(keywords, getHighlightSpanForNode);
+                }
+
+                function getTryCatchFinallyOccurrences(tryStatement: TryStatement): HighlightSpan[] {
+                    let keywords: Node[] = [];
+
+                    pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
+
+                    if (tryStatement.catchClause) {
+                        pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
+                    }
+
+                    if (tryStatement.finallyBlock) {
+                        let finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
+                        pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
+                    }
+
+                    return map(keywords, getHighlightSpanForNode);
+                }
+
+                function getThrowOccurrences(throwStatement: ThrowStatement): HighlightSpan[] {
+                    let owner = getThrowStatementOwner(throwStatement);
+
+                    if (!owner) {
+                        return undefined;
+                    }
+
+                    let keywords: Node[] = [];
+
+                    forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
+                        pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+                    });
+
+                    // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
+                    // ability to "jump out" of the function, and include occurrences for both.
+                    if (isFunctionBlock(owner)) {
+                        forEachReturnStatement(<Block>owner, returnStatement => {
+                            pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+                        });
+                    }
+
+                    return map(keywords, getHighlightSpanForNode);
+                }
+
+                function getReturnOccurrences(returnStatement: ReturnStatement): HighlightSpan[] {
+                    let func = <FunctionLikeDeclaration>getContainingFunction(returnStatement);
+
+                    // If we didn't find a containing function with a block body, bail out.
+                    if (!(func && hasKind(func.body, SyntaxKind.Block))) {
+                        return undefined;
+                    }
+
+                    let keywords: Node[] = []
+                    forEachReturnStatement(<Block>func.body, returnStatement => {
+                        pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+                    });
+
+                    // Include 'throw' statements that do not occur within a try block.
+                    forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
+                        pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+                    });
+
+                    return map(keywords, getHighlightSpanForNode);
+                }
+
+                function getIfElseOccurrences(ifStatement: IfStatement): HighlightSpan[] {
+                    let keywords: Node[] = [];
+
+                    // Traverse upwards through all parent if-statements linked by their else-branches.
+                    while (hasKind(ifStatement.parent, SyntaxKind.IfStatement) && (<IfStatement>ifStatement.parent).elseStatement === ifStatement) {
+                        ifStatement = <IfStatement>ifStatement.parent;
+                    }
+
+                    // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
+                    while (ifStatement) {
+                        let children = ifStatement.getChildren();
+                        pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
+
+                        // Generally the 'else' keyword is second-to-last, so we traverse backwards.
+                        for (let i = children.length - 1; i >= 0; i--) {
+                            if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
                                 break;
                             }
                         }
 
-                        if (shouldHighlightNextKeyword) {
-                            result.push({
-                                fileName: fileName,
-                                textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
-                                isWriteAccess: false
-                            });
-                            i++; // skip the next keyword
-                            continue;
+                        if (!hasKind(ifStatement.elseStatement, SyntaxKind.IfStatement)) {
+                            break
                         }
+
+                        ifStatement = <IfStatement>ifStatement.elseStatement;
                     }
 
-                    // Ordinary case: just highlight the keyword.
-                    result.push(getReferenceEntryFromNode(keywords[i]));
+                    let result: HighlightSpan[] = [];
+
+                    // We'd like to highlight else/ifs together if they are only separated by whitespace
+                    // (i.e. the keywords are separated by no comments, no newlines).
+                    for (let i = 0; i < keywords.length; i++) {
+                        if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
+                            let elseKeyword = keywords[i];
+                            let ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+
+                            let shouldCombindElseAndIf = true;
+
+                            // Avoid recalculating getStart() by iterating backwards.
+                            for (let j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
+                                if (!isWhiteSpace(sourceFile.text.charCodeAt(j))) {
+                                    shouldCombindElseAndIf = false;
+                                    break;
+                                }
+                            }
+
+                            if (shouldCombindElseAndIf) {
+                                result.push({
+                                    fileName: fileName,
+                                    textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
+                                    kind: HighlightSpanKind.reference
+                                });
+                                i++; // skip the next keyword
+                                continue;
+                            }
+                        }
+
+                        // Ordinary case: just highlight the keyword.
+                        result.push(getHighlightSpanForNode(keywords[i]));
+                    }
+
+                    return result;
+                }
+            }
+        }
+
+        /// References and Occurrences
+        function getOccurrencesAtPositionCore(fileName: string, position: number): ReferenceEntry[] {
+            synchronizeHostData();
+
+            return convertDocumentHighlights(getDocumentHighlights(fileName, position, [fileName]));
+
+            function convertDocumentHighlights(documentHighlights: DocumentHighlights[]): ReferenceEntry[] {
+                if (!documentHighlights) {
+                    return undefined;
+                }
+
+                let result: ReferenceEntry[] = [];
+                for (let entry of documentHighlights) {
+                    for (let highlightSpan of entry.highlightSpans) {
+                        result.push({
+                            fileName: entry.fileName,
+                            textSpan: highlightSpan.textSpan,
+                            isWriteAccess: highlightSpan.kind === HighlightSpanKind.writtenReference
+                        });
+                    }
                 }
 
                 return result;
             }
-
-            function getReturnOccurrences(returnStatement: ReturnStatement): ReferenceEntry[] {
-                let func = <FunctionLikeDeclaration>getContainingFunction(returnStatement);
-
-                // If we didn't find a containing function with a block body, bail out.
-                if (!(func && hasKind(func.body, SyntaxKind.Block))) {
-                    return undefined;
-                }
-
-                let keywords: Node[] = []
-                forEachReturnStatement(<Block>func.body, returnStatement => {
-                    pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
-                });
-
-                // Include 'throw' statements that do not occur within a try block.
-                forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
-                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
-                });
-
-                return map(keywords, getReferenceEntryFromNode);
-            }
-
-            function getThrowOccurrences(throwStatement: ThrowStatement) {
-                let owner = getThrowStatementOwner(throwStatement);
-
-                if (!owner) {
-                    return undefined;
-                }
-
-                let keywords: Node[] = [];
-
-                forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
-                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
-                });
-
-                // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
-                // ability to "jump out" of the function, and include occurrences for both.
-                if (isFunctionBlock(owner)) {
-                    forEachReturnStatement(<Block>owner, returnStatement => {
-                        pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
-                    });
-                }
-
-                return map(keywords, getReferenceEntryFromNode);
-            }
-
-            /**
-             * Aggregates all throw-statements within this node *without* crossing
-             * into function boundaries and try-blocks with catch-clauses.
-             */
-            function aggregateOwnedThrowStatements(node: Node): ThrowStatement[] {
-                let statementAccumulator: ThrowStatement[] = []
-                aggregate(node);
-                return statementAccumulator;
-
-                function aggregate(node: Node): void {
-                    if (node.kind === SyntaxKind.ThrowStatement) {
-                        statementAccumulator.push(<ThrowStatement>node);
-                    }
-                    else if (node.kind === SyntaxKind.TryStatement) {
-                        let tryStatement = <TryStatement>node;
-
-                        if (tryStatement.catchClause) {
-                            aggregate(tryStatement.catchClause);
-                        }
-                        else {
-                            // Exceptions thrown within a try block lacking a catch clause
-                            // are "owned" in the current context.
-                            aggregate(tryStatement.tryBlock);
-                        }
-
-                        if (tryStatement.finallyBlock) {
-                            aggregate(tryStatement.finallyBlock);
-                        }
-                    }
-                    // Do not cross function boundaries.
-                    else if (!isFunctionLike(node)) {
-                        forEachChild(node, aggregate);
-                    }
-                };
-            }
-
-            /**
-             * For lack of a better name, this function takes a throw statement and returns the
-             * nearest ancestor that is a try-block (whose try statement has a catch clause),
-             * function-block, or source file.
-             */
-            function getThrowStatementOwner(throwStatement: ThrowStatement): Node {
-                let child: Node = throwStatement;
-
-                while (child.parent) {
-                    let parent = child.parent;
-
-                    if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
-                        return parent;
-                    }
-                    
-                    // A throw-statement is only owned by a try-statement if the try-statement has
-                    // a catch clause, and if the throw-statement occurs within the try block.
-                    if (parent.kind === SyntaxKind.TryStatement) {
-                        let tryStatement = <TryStatement>parent;
-
-                        if (tryStatement.tryBlock === child && tryStatement.catchClause) {
-                            return child;
-                        }
-                    }
-
-                    child = parent;
-                }
-
-                return undefined;
-            }
-
-            function getTryCatchFinallyOccurrences(tryStatement: TryStatement): ReferenceEntry[] {
-                let keywords: Node[] = [];
-
-                pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
-
-                if (tryStatement.catchClause) {
-                    pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
-                }
-
-                if (tryStatement.finallyBlock) {
-                    let finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
-                    pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
-                }
-
-                return map(keywords, getReferenceEntryFromNode);
-            }
-
-            function getLoopBreakContinueOccurrences(loopNode: IterationStatement): ReferenceEntry[] {
-                let keywords: Node[] = [];
-
-                if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
-                    // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
-                    if (loopNode.kind === SyntaxKind.DoStatement) {
-                        let loopTokens = loopNode.getChildren();
-
-                        for (let i = loopTokens.length - 1; i >= 0; i--) {
-                            if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                let breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
-
-                forEach(breaksAndContinues, statement => {
-                    if (ownsBreakOrContinueStatement(loopNode, statement)) {
-                        pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
-                    }
-                });
-
-                return map(keywords, getReferenceEntryFromNode);
-            }
-
-            function getSwitchCaseDefaultOccurrences(switchStatement: SwitchStatement): ReferenceEntry[] {
-                let keywords: Node[] = [];
-
-                pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
-
-                // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
-                forEach(switchStatement.caseBlock.clauses, clause => {
-                    pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
-
-                    let breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
-
-                    forEach(breaksAndContinues, statement => {
-                        if (ownsBreakOrContinueStatement(switchStatement, statement)) {
-                            pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
-                        }
-                    });
-                });
-
-                return map(keywords, getReferenceEntryFromNode);
-            }
-
-            function getBreakOrContinueStatementOccurences(breakOrContinueStatement: BreakOrContinueStatement): ReferenceEntry[] {
-                let owner = getBreakOrContinueOwner(breakOrContinueStatement);
-
-                if (owner) {
-                    switch (owner.kind) {
-                        case SyntaxKind.ForStatement:
-                        case SyntaxKind.ForInStatement:
-                        case SyntaxKind.ForOfStatement:
-                        case SyntaxKind.DoStatement:
-                        case SyntaxKind.WhileStatement:
-                            return getLoopBreakContinueOccurrences(<IterationStatement>owner)
-                        case SyntaxKind.SwitchStatement:
-                            return getSwitchCaseDefaultOccurrences(<SwitchStatement>owner);
-
-                    }
-                }
-
-                return undefined;
-            }
-
-            function aggregateAllBreakAndContinueStatements(node: Node): BreakOrContinueStatement[] {
-                let statementAccumulator: BreakOrContinueStatement[] = []
-                aggregate(node);
-                return statementAccumulator;
-
-                function aggregate(node: Node): void {
-                    if (node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement) {
-                        statementAccumulator.push(<BreakOrContinueStatement>node);
-                    }
-                    // Do not cross function boundaries.
-                    else if (!isFunctionLike(node)) {
-                        forEachChild(node, aggregate);
-                    }
-                };
-            }
-
-            function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
-                let actualOwner = getBreakOrContinueOwner(statement);
-
-                return actualOwner && actualOwner === owner;
-            }
-
-            function getBreakOrContinueOwner(statement: BreakOrContinueStatement): Node {
-                for (let node = statement.parent; node; node = node.parent) {
-                    switch (node.kind) {
-                        case SyntaxKind.SwitchStatement:
-                            if (statement.kind === SyntaxKind.ContinueStatement) {
-                                continue;
-                            }
-                        // Fall through.
-                        case SyntaxKind.ForStatement:
-                        case SyntaxKind.ForInStatement:
-                        case SyntaxKind.ForOfStatement:
-                        case SyntaxKind.WhileStatement:
-                        case SyntaxKind.DoStatement:
-                            if (!statement.label || isLabeledBy(node, statement.label.text)) {
-                                return node;
-                            }
-                            break;
-                        default:
-                            // Don't cross function boundaries.
-                            if (isFunctionLike(node)) {
-                                return undefined;
-                            }
-                            break;
-                    }
-                }
-
-                return undefined;
-            }
-
-            function getConstructorOccurrences(constructorDeclaration: ConstructorDeclaration): ReferenceEntry[] {
-                let declarations = constructorDeclaration.symbol.getDeclarations()
-
-                let keywords: Node[] = [];
-
-                forEach(declarations, declaration => {
-                    forEach(declaration.getChildren(), token => {
-                        return pushKeywordIf(keywords, token, SyntaxKind.ConstructorKeyword);
-                    });
-                });
-
-                return map(keywords, getReferenceEntryFromNode);
-            }
-
-            function getGetAndSetOccurrences(accessorDeclaration: AccessorDeclaration): ReferenceEntry[] {
-                let keywords: Node[] = [];
-
-                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.GetAccessor);
-                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.SetAccessor);
-
-                return map(keywords, getReferenceEntryFromNode);
-
-                function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
-                    let accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
-
-                    if (accessor) {
-                        forEach(accessor.getChildren(), child => pushKeywordIf(keywords, child, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword));
-                    }
-                }
-            }
-
-            function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): ReferenceEntry[] {
-                let container = declaration.parent;
-
-                // Make sure we only highlight the keyword when it makes sense to do so.
-                if (isAccessibilityModifier(modifier)) {
-                    if (!(container.kind === SyntaxKind.ClassDeclaration ||
-                        (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) {
-                        return undefined;
-                    }
-                }
-                else if (modifier === SyntaxKind.StaticKeyword) {
-                    if (container.kind !== SyntaxKind.ClassDeclaration) {
-                        return undefined;
-                    }
-                }
-                else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) {
-                    if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) {
-                        return undefined;
-                    }
-                }
-                else { 
-                    // unsupported modifier
-                    return undefined;
-                }
-
-                let keywords: Node[] = [];
-                let modifierFlag: NodeFlags = getFlagFromModifier(modifier);
-
-                let nodes: Node[];
-                switch (container.kind) {
-                    case SyntaxKind.ModuleBlock:
-                    case SyntaxKind.SourceFile:
-                        nodes = (<Block>container).statements;
-                        break;
-                    case SyntaxKind.Constructor:
-                        nodes = (<Node[]>(<ConstructorDeclaration>container).parameters).concat(
-                            (<ClassDeclaration>container.parent).members);
-                        break;
-                    case SyntaxKind.ClassDeclaration:
-                        nodes = (<ClassDeclaration>container).members;
-
-                        // If we're an accessibility modifier, we're in an instance member and should search
-                        // the constructor's parameter list for instance members as well.
-                        if (modifierFlag & NodeFlags.AccessibilityModifier) {
-                            let constructor = forEach((<ClassDeclaration>container).members, member => {
-                                return member.kind === SyntaxKind.Constructor && <ConstructorDeclaration>member;
-                            });
-
-                            if (constructor) {
-                                nodes = nodes.concat(constructor.parameters);
-                            }
-                        }
-                        break;
-                    default:
-                        Debug.fail("Invalid container kind.")
-                }
-                
-                forEach(nodes, node => {
-                    if (node.modifiers && node.flags & modifierFlag) {
-                        forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier));
-                    }
-                });
-
-                return map(keywords, getReferenceEntryFromNode);
-
-                function getFlagFromModifier(modifier: SyntaxKind) {
-                    switch (modifier) {
-                        case SyntaxKind.PublicKeyword:
-                            return NodeFlags.Public;
-                        case SyntaxKind.PrivateKeyword:
-                            return NodeFlags.Private;
-                        case SyntaxKind.ProtectedKeyword:
-                            return NodeFlags.Protected;
-                        case SyntaxKind.StaticKeyword:
-                            return NodeFlags.Static;
-                        case SyntaxKind.ExportKeyword:
-                            return NodeFlags.Export;
-                        case SyntaxKind.DeclareKeyword:
-                            return NodeFlags.Ambient;
-                        default:
-                            Debug.fail();
-                    }
-                }
-            }
-
-            // returns true if 'node' is defined and has a matching 'kind'.
-            function hasKind(node: Node, kind: SyntaxKind) {
-                return node !== undefined && node.kind === kind;
-            }
-
-            // Null-propagating 'parent' function.
-            function parent(node: Node): Node {
-                return node && node.parent;
-            }
-
-            function pushKeywordIf(keywordList: Node[], token: Node, ...expected: SyntaxKind[]): boolean {
-                if (token && contains(expected, token.kind)) {
-                    keywordList.push(token);
-                    return true;
-                }
-
-                return false;
-            }
         }
 
-        function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[]{
+        function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
             if (!referenceSymbols) {
                 return undefined;
             }
 
             let referenceEntries: ReferenceEntry[] = [];
+
             for (let referenceSymbol of referenceSymbols) {
                 addRange(referenceEntries, referenceSymbol.references);
             }
+
             return referenceEntries;
         }
 
-        function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[]{
+        function findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[] {
             var referencedSymbols = findReferencedSymbols(fileName, position, findInStrings, findInComments);
             return convertReferences(referencedSymbols);
         }
@@ -4561,10 +4673,10 @@ module ts {
             }
 
             Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.NumericLiteral || node.kind === SyntaxKind.StringLiteral);
-            return getReferencesForNode(node, program.getSourceFiles(), /*searchOnlyInCurrentFile*/ false, findInStrings, findInComments);
+            return getReferencedSymbolsForNodes(node, program.getSourceFiles(), findInStrings, findInComments);
         }
 
-        function getReferencesForNode(node: Node, sourceFiles: SourceFile[], searchOnlyInCurrentFile: boolean, findInStrings: boolean, findInComments: boolean): ReferencedSymbol[]{
+        function getReferencedSymbolsForNodes(node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean): ReferencedSymbol[]{
             // Labels
             if (isLabelName(node)) {
                 if (isJumpStatementTarget(node)) {
@@ -4622,23 +4734,16 @@ module ts {
                 getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
             }
             else {
-                if (searchOnlyInCurrentFile) {
-                    Debug.assert(sourceFiles.length === 1);
-                    result = [];
-                    getReferencesInNode(sourceFiles[0], symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
-                }
-                else {
-                    let internedName = getInternedName(symbol, node, declarations)
-                    forEach(sourceFiles, sourceFile => {
-                        cancellationToken.throwIfCancellationRequested();
+                let internedName = getInternedName(symbol, node, declarations)
+                for (let sourceFile of sourceFiles) {
+                    cancellationToken.throwIfCancellationRequested();
 
-                        let nameTable = getNameTable(sourceFile);
+                    let nameTable = getNameTable(sourceFile);
 
-                        if (lookUp(nameTable, internedName)) {
-                            result = result || [];
-                            getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
-                        }
-                    });
+                    if (lookUp(nameTable, internedName)) {
+                        result = result || [];
+                        getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
+                    }
                 }
             }
 
@@ -6255,6 +6360,7 @@ module ts {
             getReferencesAtPosition,
             findReferences,
             getOccurrencesAtPosition,
+            getDocumentHighlights,
             getNameOrDottedNameSpan,
             getBreakpointStatementAtPosition,
             getNavigateToItems,
diff --git a/src/services/shims.ts b/src/services/shims.ts
index 7b5eeaf94d2..4872130a368 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -135,11 +135,21 @@ module ts {
         findReferences(fileName: string, position: number): string;
 
         /**
+         * @deprecated
          * Returns a JSON-encoded value of the type:
          * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean }[]
          */
         getOccurrencesAtPosition(fileName: string, position: number): string;
 
+        /**
+         * Returns a JSON-encoded value of the type:
+         * { fileName: string; highlights: { start: number; length: number, isDefinition: boolean }[] }[]
+         * 
+         * @param fileToSearch A JSON encoded string[] containing the file names that should be 
+         *  considered when searching.
+         */
+        getDocumentHighlights(fileName: string, position: number, filesToSearch: string): string;
+
         /**
          * Returns a JSON-encoded value of the type:
          * { name: string; kind: string; kindModifiers: string; containerName: string; containerKind: string; matchKind: string; fileName: string; textSpan: { start: number; length: number}; } [] = [];
@@ -590,6 +600,14 @@ module ts {
                 });
         }
 
+        public getDocumentHighlights(fileName: string, position: number, filesToSearch: string): string {
+            return this.forwardJSONCall(
+                "getDocumentHighlights('" + fileName + "', " + position + ")",
+                () => {
+                    return this.languageService.getDocumentHighlights(fileName, position, JSON.parse(filesToSearch));
+                });
+        }
+
         /// COMPLETION LISTS
 
         /**
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/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/computedPropertyNames31_ES6.js b/tests/baselines/reference/computedPropertyNames31_ES6.js
index 2c63dcee077..d17423223e3 100644
--- a/tests/baselines/reference/computedPropertyNames31_ES6.js
+++ b/tests/baselines/reference/computedPropertyNames31_ES6.js
@@ -23,7 +23,6 @@ class Base {
 }
 class C extends Base {
     foo() {
-        var _this = this;
         (() => {
             var obj = {
                 [super.bar()]() { } // needs capture
diff --git a/tests/baselines/reference/decoratorOnClass1.types b/tests/baselines/reference/decoratorOnClass1.types
index 19e066586da..91c9feb4e35 100644
--- a/tests/baselines/reference/decoratorOnClass1.types
+++ b/tests/baselines/reference/decoratorOnClass1.types
@@ -7,7 +7,7 @@ declare function dec<T>(target: T): T;
 >T : T
 
 @dec
->dec : unknown
+>dec : <T>(target: T) => T
 
 class C {
 >C : C
diff --git a/tests/baselines/reference/decoratorOnClass2.types b/tests/baselines/reference/decoratorOnClass2.types
index 43102ee9122..48565b74b43 100644
--- a/tests/baselines/reference/decoratorOnClass2.types
+++ b/tests/baselines/reference/decoratorOnClass2.types
@@ -7,7 +7,7 @@ declare function dec<T>(target: T): T;
 >T : T
 
 @dec
->dec : unknown
+>dec : <T>(target: T) => T
 
 export class C {
 >C : C
diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.types b/tests/baselines/reference/decoratorOnClassAccessor1.types
index fd592d7d294..602faf1fd22 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor1.types
+++ b/tests/baselines/reference/decoratorOnClassAccessor1.types
@@ -14,6 +14,6 @@ class C {
 >C : C
 
     @dec get accessor() { return 1; }
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 >accessor : number
 }
diff --git a/tests/baselines/reference/decoratorOnClassAccessor2.types b/tests/baselines/reference/decoratorOnClassAccessor2.types
index 32bb503d889..e43733db132 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor2.types
+++ b/tests/baselines/reference/decoratorOnClassAccessor2.types
@@ -14,6 +14,6 @@ class C {
 >C : C
 
     @dec public get accessor() { return 1; }
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 >accessor : number
 }
diff --git a/tests/baselines/reference/decoratorOnClassAccessor4.types b/tests/baselines/reference/decoratorOnClassAccessor4.types
index 40dd43d7e62..59399c5ea31 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor4.types
+++ b/tests/baselines/reference/decoratorOnClassAccessor4.types
@@ -14,7 +14,7 @@ class C {
 >C : C
 
     @dec set accessor(value: number) { }
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 >accessor : number
 >value : number
 }
diff --git a/tests/baselines/reference/decoratorOnClassAccessor5.types b/tests/baselines/reference/decoratorOnClassAccessor5.types
index 4b167fe8df1..8fe5ee55368 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor5.types
+++ b/tests/baselines/reference/decoratorOnClassAccessor5.types
@@ -14,7 +14,7 @@ class C {
 >C : C
 
     @dec public set accessor(value: number) { }
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 >accessor : number
 >value : number
 }
diff --git a/tests/baselines/reference/decoratorOnClassConstructorParameter1.types b/tests/baselines/reference/decoratorOnClassConstructorParameter1.types
index d5ce51269bc..a325945d8a2 100644
--- a/tests/baselines/reference/decoratorOnClassConstructorParameter1.types
+++ b/tests/baselines/reference/decoratorOnClassConstructorParameter1.types
@@ -10,6 +10,6 @@ class C {
 >C : C
 
     constructor(@dec p: number) {}
->dec : unknown
+>dec : (target: Function, propertyKey: string | symbol, parameterIndex: number) => void
 >p : number
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod1.types b/tests/baselines/reference/decoratorOnClassMethod1.types
index 760f758bbff..fc7f27c5dfb 100644
--- a/tests/baselines/reference/decoratorOnClassMethod1.types
+++ b/tests/baselines/reference/decoratorOnClassMethod1.types
@@ -14,6 +14,6 @@ class C {
 >C : C
 
     @dec method() {}
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 >method : () => void
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod11.js b/tests/baselines/reference/decoratorOnClassMethod11.js
index 71d4298f02c..f8276de2fe3 100644
--- a/tests/baselines/reference/decoratorOnClassMethod11.js
+++ b/tests/baselines/reference/decoratorOnClassMethod11.js
@@ -1,11 +1,11 @@
 //// [decoratorOnClassMethod11.ts]
-module M {
-    class C {
-        decorator(target: Object, key: string): void { }
-
-        @this.decorator
-        method() { }
-    }
+module M {
+    class C {
+        decorator(target: Object, key: string): void { }
+
+        @this.decorator
+        method() { }
+    }
 }
 
 //// [decoratorOnClassMethod11.js]
diff --git a/tests/baselines/reference/decoratorOnClassMethod13.types b/tests/baselines/reference/decoratorOnClassMethod13.types
index 8c34805792f..1390f5750e6 100644
--- a/tests/baselines/reference/decoratorOnClassMethod13.types
+++ b/tests/baselines/reference/decoratorOnClassMethod13.types
@@ -14,8 +14,8 @@ class C {
 >C : C
 
     @dec ["1"]() { }
->dec : unknown
+>dec : () => <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 
     @dec ["b"]() { }
->dec : unknown
+>dec : () => <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod2.types b/tests/baselines/reference/decoratorOnClassMethod2.types
index 98539648cd0..b83605c9c3c 100644
--- a/tests/baselines/reference/decoratorOnClassMethod2.types
+++ b/tests/baselines/reference/decoratorOnClassMethod2.types
@@ -14,6 +14,6 @@ class C {
 >C : C
 
     @dec public method() {}
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 >method : () => void
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod4.types b/tests/baselines/reference/decoratorOnClassMethod4.types
index 6d55e01e97a..5b48b267e1d 100644
--- a/tests/baselines/reference/decoratorOnClassMethod4.types
+++ b/tests/baselines/reference/decoratorOnClassMethod4.types
@@ -14,5 +14,5 @@ class C {
 >C : C
 
     @dec ["method"]() {}
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod6.types b/tests/baselines/reference/decoratorOnClassMethod6.types
index 4e6629cd60a..8b167b5fb0f 100644
--- a/tests/baselines/reference/decoratorOnClassMethod6.types
+++ b/tests/baselines/reference/decoratorOnClassMethod6.types
@@ -14,5 +14,5 @@ class C {
 >C : C
 
     @dec ["method"]() {}
->dec : unknown
+>dec : () => <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod7.types b/tests/baselines/reference/decoratorOnClassMethod7.types
index 7e426cb773c..038d3ca7df5 100644
--- a/tests/baselines/reference/decoratorOnClassMethod7.types
+++ b/tests/baselines/reference/decoratorOnClassMethod7.types
@@ -14,5 +14,5 @@ class C {
 >C : C
 
     @dec public ["method"]() {}
->dec : unknown
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethod8.types b/tests/baselines/reference/decoratorOnClassMethod8.types
index f932ab8696f..20890b09846 100644
--- a/tests/baselines/reference/decoratorOnClassMethod8.types
+++ b/tests/baselines/reference/decoratorOnClassMethod8.types
@@ -10,6 +10,6 @@ class C {
 >C : C
 
     @dec method() {}
->dec : unknown
+>dec : <T>(target: T) => T
 >method : () => void
 }
diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.types b/tests/baselines/reference/decoratorOnClassMethodParameter1.types
index cf7bfd352bf..0b75471471f 100644
--- a/tests/baselines/reference/decoratorOnClassMethodParameter1.types
+++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.types
@@ -11,6 +11,6 @@ class C {
 
     method(@dec p: number) {}
 >method : (p: number) => void
->dec : unknown
+>dec : (target: Function, propertyKey: string | symbol, parameterIndex: number) => void
 >p : number
 }
diff --git a/tests/baselines/reference/decoratorOnClassProperty1.types b/tests/baselines/reference/decoratorOnClassProperty1.types
index 651085c7ac4..e974397e532 100644
--- a/tests/baselines/reference/decoratorOnClassProperty1.types
+++ b/tests/baselines/reference/decoratorOnClassProperty1.types
@@ -8,6 +8,6 @@ class C {
 >C : C
 
     @dec prop;
->dec : unknown
+>dec : (target: any, propertyKey: string) => void
 >prop : any
 }
diff --git a/tests/baselines/reference/decoratorOnClassProperty11.types b/tests/baselines/reference/decoratorOnClassProperty11.types
index 5377e53c31c..5caa467d3ba 100644
--- a/tests/baselines/reference/decoratorOnClassProperty11.types
+++ b/tests/baselines/reference/decoratorOnClassProperty11.types
@@ -9,6 +9,6 @@ class C {
 >C : C
 
     @dec prop;
->dec : unknown
+>dec : () => <T>(target: any, propertyKey: string) => void
 >prop : any
 }
diff --git a/tests/baselines/reference/decoratorOnClassProperty2.types b/tests/baselines/reference/decoratorOnClassProperty2.types
index 2d5c9fe07d7..78d35004f8f 100644
--- a/tests/baselines/reference/decoratorOnClassProperty2.types
+++ b/tests/baselines/reference/decoratorOnClassProperty2.types
@@ -8,6 +8,6 @@ class C {
 >C : C
 
     @dec public prop;
->dec : unknown
+>dec : (target: any, propertyKey: string) => void
 >prop : any
 }
diff --git a/tests/baselines/reference/decoratorOnClassProperty6.types b/tests/baselines/reference/decoratorOnClassProperty6.types
index 2c8c41abf78..59d03678330 100644
--- a/tests/baselines/reference/decoratorOnClassProperty6.types
+++ b/tests/baselines/reference/decoratorOnClassProperty6.types
@@ -8,6 +8,6 @@ class C {
 >C : C
 
     @dec prop;
->dec : unknown
+>dec : (target: Function) => void
 >prop : any
 }
diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js
new file mode 100644
index 00000000000..77b91730156
--- /dev/null
+++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.js
@@ -0,0 +1,23 @@
+//// [emitClassDeclarationWithSuperMethodCall01.ts]
+
+class Parent {
+    foo() {
+    }
+}
+
+class Foo extends Parent {
+    foo() {
+        var x = () => super.foo();
+    }
+}
+
+//// [emitClassDeclarationWithSuperMethodCall01.js]
+class Parent {
+    foo() {
+    }
+}
+class Foo extends Parent {
+    foo() {
+        var x = () => super.foo();
+    }
+}
diff --git a/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types
new file mode 100644
index 00000000000..8b68af897ac
--- /dev/null
+++ b/tests/baselines/reference/emitClassDeclarationWithSuperMethodCall01.types
@@ -0,0 +1,26 @@
+=== tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts ===
+
+class Parent {
+>Parent : Parent
+
+    foo() {
+>foo : () => void
+    }
+}
+
+class Foo extends Parent {
+>Foo : Foo
+>Parent : Parent
+
+    foo() {
+>foo : () => void
+
+        var x = () => super.foo();
+>x : () => void
+>() => super.foo() : () => void
+>super.foo() : void
+>super.foo : () => void
+>super : Parent
+>foo : () => void
+    }
+}
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/parserSymbolProperty4.js b/tests/baselines/reference/parserSymbolProperty4.js
index f79db0b1d79..698798351ac 100644
--- a/tests/baselines/reference/parserSymbolProperty4.js
+++ b/tests/baselines/reference/parserSymbolProperty4.js
@@ -1,6 +1,6 @@
 //// [parserSymbolProperty4.ts]
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }
 
 //// [parserSymbolProperty4.js]
diff --git a/tests/baselines/reference/parserSymbolProperty4.types b/tests/baselines/reference/parserSymbolProperty4.types
index a9070897fa8..dbf65454826 100644
--- a/tests/baselines/reference/parserSymbolProperty4.types
+++ b/tests/baselines/reference/parserSymbolProperty4.types
@@ -2,8 +2,8 @@
 declare class C {
 >C : C
 
-    [Symbol.isRegExp]: string;
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]: string;
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 }
diff --git a/tests/baselines/reference/parserSymbolProperty5.js b/tests/baselines/reference/parserSymbolProperty5.js
index a8b1d564fa8..62a805602d1 100644
--- a/tests/baselines/reference/parserSymbolProperty5.js
+++ b/tests/baselines/reference/parserSymbolProperty5.js
@@ -1,6 +1,6 @@
 //// [parserSymbolProperty5.ts]
 class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }
 
 //// [parserSymbolProperty5.js]
diff --git a/tests/baselines/reference/parserSymbolProperty5.types b/tests/baselines/reference/parserSymbolProperty5.types
index 8a171598e83..c854aa6a26d 100644
--- a/tests/baselines/reference/parserSymbolProperty5.types
+++ b/tests/baselines/reference/parserSymbolProperty5.types
@@ -2,8 +2,8 @@
 class C {
 >C : C
 
-    [Symbol.isRegExp]: string;
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]: string;
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 }
diff --git a/tests/baselines/reference/sourceMapValidationDecorators.types b/tests/baselines/reference/sourceMapValidationDecorators.types
index 8be7f237391..05b512fa439 100644
--- a/tests/baselines/reference/sourceMapValidationDecorators.types
+++ b/tests/baselines/reference/sourceMapValidationDecorators.types
@@ -43,7 +43,7 @@ declare function ParameterDecorator2(x: number): (target: Function, key: string
 >paramIndex : number
 
 @ClassDecorator1
->ClassDecorator1 : unknown
+>ClassDecorator1 : (target: Function) => void
 
 @ClassDecorator2(10)
 >ClassDecorator2(10) : (target: Function) => void
@@ -54,7 +54,7 @@ class Greeter {
 
     constructor(
       @ParameterDecorator1 
->ParameterDecorator1 : unknown
+>ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void
 
       @ParameterDecorator2(20) 
 >ParameterDecorator2(20) : (target: Function, key: string | symbol, paramIndex: number) => void
@@ -64,7 +64,7 @@ class Greeter {
 >greeting : string
       
       @ParameterDecorator1 
->ParameterDecorator1 : unknown
+>ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void
 
       @ParameterDecorator2(30) 
 >ParameterDecorator2(30) : (target: Function, key: string | symbol, paramIndex: number) => void
@@ -75,7 +75,7 @@ class Greeter {
     }
     
     @PropertyDecorator1
->PropertyDecorator1 : unknown
+>PropertyDecorator1 : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
 
     @PropertyDecorator2(40)
 >PropertyDecorator2(40) : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
@@ -93,7 +93,7 @@ class Greeter {
     }
 
     @PropertyDecorator1
->PropertyDecorator1 : unknown
+>PropertyDecorator1 : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
 
     @PropertyDecorator2(50)
 >PropertyDecorator2(50) : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
@@ -103,7 +103,7 @@ class Greeter {
 >x : string
 
     @PropertyDecorator1
->PropertyDecorator1 : unknown
+>PropertyDecorator1 : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
 
     @PropertyDecorator2(60)
 >PropertyDecorator2(60) : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
@@ -116,7 +116,7 @@ class Greeter {
 >fn : (x: number) => string
 
       @ParameterDecorator1 
->ParameterDecorator1 : unknown
+>ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void
 
       @ParameterDecorator2(70) 
 >ParameterDecorator2(70) : (target: Function, key: string | symbol, paramIndex: number) => void
@@ -132,7 +132,7 @@ class Greeter {
     }
 
     @PropertyDecorator1
->PropertyDecorator1 : unknown
+>PropertyDecorator1 : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
 
     @PropertyDecorator2(80)
 >PropertyDecorator2(80) : (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void
@@ -151,7 +151,7 @@ class Greeter {
 >greetings : string
 
       @ParameterDecorator1 
->ParameterDecorator1 : unknown
+>ParameterDecorator1 : (target: Function, key: string | symbol, paramIndex: number) => void
 
       @ParameterDecorator2(90) 
 >ParameterDecorator2(90) : (target: Function, key: string | symbol, paramIndex: number) => void
diff --git a/tests/baselines/reference/symbolDeclarationEmit1.js b/tests/baselines/reference/symbolDeclarationEmit1.js
index 7c3b39b9d86..b8ca5495ba7 100644
--- a/tests/baselines/reference/symbolDeclarationEmit1.js
+++ b/tests/baselines/reference/symbolDeclarationEmit1.js
@@ -1,6 +1,6 @@
 //// [symbolDeclarationEmit1.ts]
 class C {
-    [Symbol.isRegExp]: number;
+    [Symbol.toPrimitive]: number;
 }
 
 //// [symbolDeclarationEmit1.js]
@@ -10,5 +10,5 @@ class C {
 
 //// [symbolDeclarationEmit1.d.ts]
 declare class C {
-    [Symbol.isRegExp]: number;
+    [Symbol.toPrimitive]: number;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit1.types b/tests/baselines/reference/symbolDeclarationEmit1.types
index e35bbfe8861..741f2a74bd7 100644
--- a/tests/baselines/reference/symbolDeclarationEmit1.types
+++ b/tests/baselines/reference/symbolDeclarationEmit1.types
@@ -2,8 +2,8 @@
 class C {
 >C : C
 
-    [Symbol.isRegExp]: number;
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]: number;
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit11.js b/tests/baselines/reference/symbolDeclarationEmit11.js
index b5983177587..25af4c43064 100644
--- a/tests/baselines/reference/symbolDeclarationEmit11.js
+++ b/tests/baselines/reference/symbolDeclarationEmit11.js
@@ -1,16 +1,16 @@
 //// [symbolDeclarationEmit11.ts]
 class C {
     static [Symbol.iterator] = 0;
-    static [Symbol.toPrimitive]() { }
-    static get [Symbol.isRegExp]() { return ""; }
-    static set [Symbol.isRegExp](x) { }
+    static [Symbol.isConcatSpreadable]() { }
+    static get [Symbol.toPrimitive]() { return ""; }
+    static set [Symbol.toPrimitive](x) { }
 }
 
 //// [symbolDeclarationEmit11.js]
 class C {
-    static [Symbol.toPrimitive]() { }
-    static get [Symbol.isRegExp]() { return ""; }
-    static set [Symbol.isRegExp](x) { }
+    static [Symbol.isConcatSpreadable]() { }
+    static get [Symbol.toPrimitive]() { return ""; }
+    static set [Symbol.toPrimitive](x) { }
 }
 C[Symbol.iterator] = 0;
 
@@ -18,6 +18,6 @@ C[Symbol.iterator] = 0;
 //// [symbolDeclarationEmit11.d.ts]
 declare class C {
     static [Symbol.iterator]: number;
-    static [Symbol.toPrimitive](): void;
-    static [Symbol.isRegExp]: string;
+    static [Symbol.isConcatSpreadable](): void;
+    static [Symbol.toPrimitive]: string;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit11.types b/tests/baselines/reference/symbolDeclarationEmit11.types
index 1bf58f205d1..9189e69dc04 100644
--- a/tests/baselines/reference/symbolDeclarationEmit11.types
+++ b/tests/baselines/reference/symbolDeclarationEmit11.types
@@ -7,19 +7,19 @@ class C {
 >Symbol : SymbolConstructor
 >iterator : symbol
 
-    static [Symbol.toPrimitive]() { }
+    static [Symbol.isConcatSpreadable]() { }
+>Symbol.isConcatSpreadable : symbol
+>Symbol : SymbolConstructor
+>isConcatSpreadable : symbol
+
+    static get [Symbol.toPrimitive]() { return ""; }
 >Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
 >toPrimitive : symbol
 
-    static get [Symbol.isRegExp]() { return ""; }
->Symbol.isRegExp : symbol
+    static set [Symbol.toPrimitive](x) { }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
-
-    static set [Symbol.isRegExp](x) { }
->Symbol.isRegExp : symbol
->Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 >x : string
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit12.errors.txt b/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
index 0e2f6b828f6..cdc712f698d 100644
--- a/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
+++ b/tests/baselines/reference/symbolDeclarationEmit12.errors.txt
@@ -1,10 +1,13 @@
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(4,28): error TS4031: Public property '[Symbol.iterator]' of exported class has or is using private name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,9): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(5,33): error TS4073: Parameter 'x' of public method from exported class has or is using private name 'I'.
 tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(6,40): error TS4055: Return type of public method from exported class has or is using private name 'I'.
-tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,34): error TS4037: Parameter '[Symbol.isRegExp]' of public property setter from exported class has or is using private name 'I'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(9,13): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,13): error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
+tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,37): error TS4037: Parameter '[Symbol.toPrimitive]' of public property setter from exported class has or is using private name 'I'.
 
 
-==== tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts (4 errors) ====
+==== tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts (7 errors) ====
     module M {
         interface I { }
         export class C {
@@ -12,6 +15,8 @@ tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,34): error TS4
                                ~
 !!! error TS4031: Public property '[Symbol.iterator]' of exported class has or is using private name 'I'.
             [Symbol.toPrimitive](x: I) { }
+            ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
                                     ~
 !!! error TS4073: Parameter 'x' of public method from exported class has or is using private name 'I'.
             [Symbol.isConcatSpreadable](): I {
@@ -19,9 +24,13 @@ tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts(10,34): error TS4
 !!! error TS4055: Return type of public method from exported class has or is using private name 'I'.
                 return undefined
             }
-            get [Symbol.isRegExp]() { return undefined; }
-            set [Symbol.isRegExp](x: I) { }
-                                     ~
-!!! error TS4037: Parameter '[Symbol.isRegExp]' of public property setter from exported class has or is using private name 'I'.
+            get [Symbol.toPrimitive]() { return undefined; }
+                ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
+            set [Symbol.toPrimitive](x: I) { }
+                ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2300: Duplicate identifier '[Symbol.toPrimitive]'.
+                                        ~
+!!! error TS4037: Parameter '[Symbol.toPrimitive]' of public property setter from exported class has or is using private name 'I'.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/symbolDeclarationEmit12.js b/tests/baselines/reference/symbolDeclarationEmit12.js
index ce7b3861b0b..bd50f6566ac 100644
--- a/tests/baselines/reference/symbolDeclarationEmit12.js
+++ b/tests/baselines/reference/symbolDeclarationEmit12.js
@@ -7,8 +7,8 @@ module M {
         [Symbol.isConcatSpreadable](): I {
             return undefined
         }
-        get [Symbol.isRegExp]() { return undefined; }
-        set [Symbol.isRegExp](x: I) { }
+        get [Symbol.toPrimitive]() { return undefined; }
+        set [Symbol.toPrimitive](x: I) { }
     }
 }
 
@@ -20,8 +20,8 @@ var M;
         [Symbol.isConcatSpreadable]() {
             return undefined;
         }
-        get [Symbol.isRegExp]() { return undefined; }
-        set [Symbol.isRegExp](x) { }
+        get [Symbol.toPrimitive]() { return undefined; }
+        set [Symbol.toPrimitive](x) { }
     }
     M.C = C;
 })(M || (M = {}));
diff --git a/tests/baselines/reference/symbolDeclarationEmit13.js b/tests/baselines/reference/symbolDeclarationEmit13.js
index b309cfb2f64..8111672866a 100644
--- a/tests/baselines/reference/symbolDeclarationEmit13.js
+++ b/tests/baselines/reference/symbolDeclarationEmit13.js
@@ -1,18 +1,18 @@
 //// [symbolDeclarationEmit13.ts]
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     set [Symbol.toStringTag](x) { }
 }
 
 //// [symbolDeclarationEmit13.js]
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     set [Symbol.toStringTag](x) { }
 }
 
 
 //// [symbolDeclarationEmit13.d.ts]
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
     [Symbol.toStringTag]: any;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit13.types b/tests/baselines/reference/symbolDeclarationEmit13.types
index 6579e49c426..92ad2ad0f68 100644
--- a/tests/baselines/reference/symbolDeclarationEmit13.types
+++ b/tests/baselines/reference/symbolDeclarationEmit13.types
@@ -2,10 +2,10 @@
 class C {
 >C : C
 
-    get [Symbol.isRegExp]() { return ""; }
->Symbol.isRegExp : symbol
+    get [Symbol.toPrimitive]() { return ""; }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 
     set [Symbol.toStringTag](x) { }
 >Symbol.toStringTag : symbol
diff --git a/tests/baselines/reference/symbolDeclarationEmit14.js b/tests/baselines/reference/symbolDeclarationEmit14.js
index f24ce11ee77..b8a6b3e4092 100644
--- a/tests/baselines/reference/symbolDeclarationEmit14.js
+++ b/tests/baselines/reference/symbolDeclarationEmit14.js
@@ -1,18 +1,18 @@
 //// [symbolDeclarationEmit14.ts]
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     get [Symbol.toStringTag]() { return ""; }
 }
 
 //// [symbolDeclarationEmit14.js]
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     get [Symbol.toStringTag]() { return ""; }
 }
 
 
 //// [symbolDeclarationEmit14.d.ts]
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
     [Symbol.toStringTag]: string;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit14.types b/tests/baselines/reference/symbolDeclarationEmit14.types
index f3e7c32047c..f72bd774709 100644
--- a/tests/baselines/reference/symbolDeclarationEmit14.types
+++ b/tests/baselines/reference/symbolDeclarationEmit14.types
@@ -2,10 +2,10 @@
 class C {
 >C : C
 
-    get [Symbol.isRegExp]() { return ""; }
->Symbol.isRegExp : symbol
+    get [Symbol.toPrimitive]() { return ""; }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 
     get [Symbol.toStringTag]() { return ""; }
 >Symbol.toStringTag : symbol
diff --git a/tests/baselines/reference/symbolDeclarationEmit2.js b/tests/baselines/reference/symbolDeclarationEmit2.js
index 5558bebc64e..3fde1f6b467 100644
--- a/tests/baselines/reference/symbolDeclarationEmit2.js
+++ b/tests/baselines/reference/symbolDeclarationEmit2.js
@@ -1,17 +1,17 @@
 //// [symbolDeclarationEmit2.ts]
 class C {
-    [Symbol.isRegExp] = "";
+    [Symbol.toPrimitive] = "";
 }
 
 //// [symbolDeclarationEmit2.js]
 class C {
     constructor() {
-        this[Symbol.isRegExp] = "";
+        this[Symbol.toPrimitive] = "";
     }
 }
 
 
 //// [symbolDeclarationEmit2.d.ts]
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit2.types b/tests/baselines/reference/symbolDeclarationEmit2.types
index 4844b2b8f84..4147eeae401 100644
--- a/tests/baselines/reference/symbolDeclarationEmit2.types
+++ b/tests/baselines/reference/symbolDeclarationEmit2.types
@@ -2,8 +2,8 @@
 class C {
 >C : C
 
-    [Symbol.isRegExp] = "";
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive] = "";
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit3.js b/tests/baselines/reference/symbolDeclarationEmit3.js
index 88087982013..09cea3468ef 100644
--- a/tests/baselines/reference/symbolDeclarationEmit3.js
+++ b/tests/baselines/reference/symbolDeclarationEmit3.js
@@ -1,18 +1,18 @@
 //// [symbolDeclarationEmit3.ts]
 class C {
-    [Symbol.isRegExp](x: number);
-    [Symbol.isRegExp](x: string);
-    [Symbol.isRegExp](x: any) { }
+    [Symbol.toPrimitive](x: number);
+    [Symbol.toPrimitive](x: string);
+    [Symbol.toPrimitive](x: any) { }
 }
 
 //// [symbolDeclarationEmit3.js]
 class C {
-    [Symbol.isRegExp](x) { }
+    [Symbol.toPrimitive](x) { }
 }
 
 
 //// [symbolDeclarationEmit3.d.ts]
 declare class C {
-    [Symbol.isRegExp](x: number): any;
-    [Symbol.isRegExp](x: string): any;
+    [Symbol.toPrimitive](x: number): any;
+    [Symbol.toPrimitive](x: string): any;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit3.types b/tests/baselines/reference/symbolDeclarationEmit3.types
index 0ea55d876b3..699a7f4c864 100644
--- a/tests/baselines/reference/symbolDeclarationEmit3.types
+++ b/tests/baselines/reference/symbolDeclarationEmit3.types
@@ -2,21 +2,21 @@
 class C {
 >C : C
 
-    [Symbol.isRegExp](x: number);
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive](x: number);
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 >x : number
 
-    [Symbol.isRegExp](x: string);
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive](x: string);
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 >x : string
 
-    [Symbol.isRegExp](x: any) { }
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive](x: any) { }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 >x : any
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit4.js b/tests/baselines/reference/symbolDeclarationEmit4.js
index 67ec3477f7d..75680aacb66 100644
--- a/tests/baselines/reference/symbolDeclarationEmit4.js
+++ b/tests/baselines/reference/symbolDeclarationEmit4.js
@@ -1,17 +1,17 @@
 //// [symbolDeclarationEmit4.ts]
 class C {
-    get [Symbol.isRegExp]() { return ""; }
-    set [Symbol.isRegExp](x) { }
+    get [Symbol.toPrimitive]() { return ""; }
+    set [Symbol.toPrimitive](x) { }
 }
 
 //// [symbolDeclarationEmit4.js]
 class C {
-    get [Symbol.isRegExp]() { return ""; }
-    set [Symbol.isRegExp](x) { }
+    get [Symbol.toPrimitive]() { return ""; }
+    set [Symbol.toPrimitive](x) { }
 }
 
 
 //// [symbolDeclarationEmit4.d.ts]
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit4.types b/tests/baselines/reference/symbolDeclarationEmit4.types
index aeb24fc146c..5c3c0b0d6b6 100644
--- a/tests/baselines/reference/symbolDeclarationEmit4.types
+++ b/tests/baselines/reference/symbolDeclarationEmit4.types
@@ -2,14 +2,14 @@
 class C {
 >C : C
 
-    get [Symbol.isRegExp]() { return ""; }
->Symbol.isRegExp : symbol
+    get [Symbol.toPrimitive]() { return ""; }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 
-    set [Symbol.isRegExp](x) { }
->Symbol.isRegExp : symbol
+    set [Symbol.toPrimitive](x) { }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 >x : string
 }
diff --git a/tests/baselines/reference/symbolProperty21.js b/tests/baselines/reference/symbolProperty21.js
index 13eaf06a97b..8a93cc2de78 100644
--- a/tests/baselines/reference/symbolProperty21.js
+++ b/tests/baselines/reference/symbolProperty21.js
@@ -8,13 +8,13 @@ declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
 
 foo({
     [Symbol.isConcatSpreadable]: "",
-    [Symbol.isRegExp]: 0,
+    [Symbol.toPrimitive]: 0,
     [Symbol.unscopables]: true
 });
 
 //// [symbolProperty21.js]
 foo({
     [Symbol.isConcatSpreadable]: "",
-    [Symbol.isRegExp]: 0,
+    [Symbol.toPrimitive]: 0,
     [Symbol.unscopables]: true
 });
diff --git a/tests/baselines/reference/symbolProperty21.types b/tests/baselines/reference/symbolProperty21.types
index 053dae46479..cb4b5e74473 100644
--- a/tests/baselines/reference/symbolProperty21.types
+++ b/tests/baselines/reference/symbolProperty21.types
@@ -31,19 +31,19 @@ declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
 >U : U
 
 foo({
->foo({    [Symbol.isConcatSpreadable]: "",    [Symbol.isRegExp]: 0,    [Symbol.unscopables]: true}) : { t: boolean; u: string; }
+>foo({    [Symbol.isConcatSpreadable]: "",    [Symbol.toPrimitive]: 0,    [Symbol.unscopables]: true}) : { t: boolean; u: string; }
 >foo : <T, U>(p: I<T, U>) => { t: T; u: U; }
->{    [Symbol.isConcatSpreadable]: "",    [Symbol.isRegExp]: 0,    [Symbol.unscopables]: true} : { [Symbol.isConcatSpreadable]: string; [Symbol.isRegExp]: number; [Symbol.unscopables]: boolean; }
+>{    [Symbol.isConcatSpreadable]: "",    [Symbol.toPrimitive]: 0,    [Symbol.unscopables]: true} : { [Symbol.isConcatSpreadable]: string; [Symbol.toPrimitive]: number; [Symbol.unscopables]: boolean; }
 
     [Symbol.isConcatSpreadable]: "",
 >Symbol.isConcatSpreadable : symbol
 >Symbol : SymbolConstructor
 >isConcatSpreadable : symbol
 
-    [Symbol.isRegExp]: 0,
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]: 0,
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 
     [Symbol.unscopables]: true
 >Symbol.unscopables : symbol
diff --git a/tests/baselines/reference/symbolProperty5.js b/tests/baselines/reference/symbolProperty5.js
index c7c88681f8a..5726e42edf5 100644
--- a/tests/baselines/reference/symbolProperty5.js
+++ b/tests/baselines/reference/symbolProperty5.js
@@ -1,7 +1,7 @@
 //// [symbolProperty5.ts]
 var x = {
     [Symbol.iterator]: 0,
-    [Symbol.isRegExp]() { },
+    [Symbol.toPrimitive]() { },
     get [Symbol.toStringTag]() {
         return 0;
     }
@@ -10,7 +10,7 @@ var x = {
 //// [symbolProperty5.js]
 var x = {
     [Symbol.iterator]: 0,
-    [Symbol.isRegExp]() { },
+    [Symbol.toPrimitive]() { },
     get [Symbol.toStringTag]() {
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty5.types b/tests/baselines/reference/symbolProperty5.types
index 7d6a9f05858..e1fb096ebc4 100644
--- a/tests/baselines/reference/symbolProperty5.types
+++ b/tests/baselines/reference/symbolProperty5.types
@@ -1,17 +1,17 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty5.ts ===
 var x = {
->x : { [Symbol.iterator]: number; [Symbol.isRegExp](): void; [Symbol.toStringTag]: number; }
->{    [Symbol.iterator]: 0,    [Symbol.isRegExp]() { },    get [Symbol.toStringTag]() {        return 0;    }} : { [Symbol.iterator]: number; [Symbol.isRegExp](): void; [Symbol.toStringTag]: number; }
+>x : { [Symbol.iterator]: number; [Symbol.toPrimitive](): void; [Symbol.toStringTag]: number; }
+>{    [Symbol.iterator]: 0,    [Symbol.toPrimitive]() { },    get [Symbol.toStringTag]() {        return 0;    }} : { [Symbol.iterator]: number; [Symbol.toPrimitive](): void; [Symbol.toStringTag]: number; }
 
     [Symbol.iterator]: 0,
 >Symbol.iterator : symbol
 >Symbol : SymbolConstructor
 >iterator : symbol
 
-    [Symbol.isRegExp]() { },
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]() { },
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 
     get [Symbol.toStringTag]() {
 >Symbol.toStringTag : symbol
diff --git a/tests/baselines/reference/symbolProperty6.js b/tests/baselines/reference/symbolProperty6.js
index 81be3e2a927..ab9564c35e5 100644
--- a/tests/baselines/reference/symbolProperty6.js
+++ b/tests/baselines/reference/symbolProperty6.js
@@ -2,7 +2,7 @@
 class C {
     [Symbol.iterator] = 0;
     [Symbol.unscopables]: number;
-    [Symbol.isRegExp]() { }
+    [Symbol.toPrimitive]() { }
     get [Symbol.toStringTag]() {
         return 0;
     }
@@ -13,7 +13,7 @@ class C {
     constructor() {
         this[Symbol.iterator] = 0;
     }
-    [Symbol.isRegExp]() { }
+    [Symbol.toPrimitive]() { }
     get [Symbol.toStringTag]() {
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty6.types b/tests/baselines/reference/symbolProperty6.types
index e5aac6f48da..20c5d0c6c8b 100644
--- a/tests/baselines/reference/symbolProperty6.types
+++ b/tests/baselines/reference/symbolProperty6.types
@@ -12,10 +12,10 @@ class C {
 >Symbol : SymbolConstructor
 >unscopables : symbol
 
-    [Symbol.isRegExp]() { }
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]() { }
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 
     get [Symbol.toStringTag]() {
 >Symbol.toStringTag : symbol
diff --git a/tests/baselines/reference/symbolProperty8.js b/tests/baselines/reference/symbolProperty8.js
index 6f3ec6cfa26..87e56802391 100644
--- a/tests/baselines/reference/symbolProperty8.js
+++ b/tests/baselines/reference/symbolProperty8.js
@@ -1,7 +1,7 @@
 //// [symbolProperty8.ts]
 interface I {
     [Symbol.unscopables]: number;
-    [Symbol.isRegExp]();
+    [Symbol.toPrimitive]();
 }
 
 //// [symbolProperty8.js]
diff --git a/tests/baselines/reference/symbolProperty8.types b/tests/baselines/reference/symbolProperty8.types
index d6c2f464b53..647cff252ab 100644
--- a/tests/baselines/reference/symbolProperty8.types
+++ b/tests/baselines/reference/symbolProperty8.types
@@ -7,8 +7,8 @@ interface I {
 >Symbol : SymbolConstructor
 >unscopables : symbol
 
-    [Symbol.isRegExp]();
->Symbol.isRegExp : symbol
+    [Symbol.toPrimitive]();
+>Symbol.toPrimitive : symbol
 >Symbol : SymbolConstructor
->isRegExp : symbol
+>toPrimitive : symbol
 }
diff --git a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts
index e3d94ff25d2..6f80fa00bca 100644
--- a/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts
+++ b/tests/cases/conformance/decorators/class/method/decoratorOnClassMethod11.ts
@@ -1,9 +1,9 @@
-// @target: ES5
-module M {
-    class C {
-        decorator(target: Object, key: string): void { }
-
-        @this.decorator
-        method() { }
-    }
+// @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/es6/Symbols/symbolDeclarationEmit1.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit1.ts
index b99806a1eee..1f4755e5203 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit1.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit1.ts
@@ -1,5 +1,5 @@
 //@target: ES6
 //@declaration: true
 class C {
-    [Symbol.isRegExp]: number;
+    [Symbol.toPrimitive]: number;
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit11.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit11.ts
index 4b88ab55980..137ada282f3 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit11.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit11.ts
@@ -2,7 +2,7 @@
 //@declaration: true
 class C {
     static [Symbol.iterator] = 0;
-    static [Symbol.toPrimitive]() { }
-    static get [Symbol.isRegExp]() { return ""; }
-    static set [Symbol.isRegExp](x) { }
+    static [Symbol.isConcatSpreadable]() { }
+    static get [Symbol.toPrimitive]() { return ""; }
+    static set [Symbol.toPrimitive](x) { }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts
index c18b470d35d..8422b1ec016 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit12.ts
@@ -8,7 +8,7 @@ module M {
         [Symbol.isConcatSpreadable](): I {
             return undefined
         }
-        get [Symbol.isRegExp]() { return undefined; }
-        set [Symbol.isRegExp](x: I) { }
+        get [Symbol.toPrimitive]() { return undefined; }
+        set [Symbol.toPrimitive](x: I) { }
     }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit13.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit13.ts
index 18568e853e8..4e65648acca 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit13.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit13.ts
@@ -1,6 +1,6 @@
 //@target: ES6
 //@declaration: true
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     set [Symbol.toStringTag](x) { }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit14.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit14.ts
index 312476628b8..c31629c82df 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit14.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit14.ts
@@ -1,6 +1,6 @@
 //@target: ES6
 //@declaration: true
 class C {
-    get [Symbol.isRegExp]() { return ""; }
+    get [Symbol.toPrimitive]() { return ""; }
     get [Symbol.toStringTag]() { return ""; }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit2.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit2.ts
index 420e1c84906..f5b00918b7e 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit2.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit2.ts
@@ -1,5 +1,5 @@
 //@target: ES6
 //@declaration: true
 class C {
-    [Symbol.isRegExp] = "";
+    [Symbol.toPrimitive] = "";
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit3.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit3.ts
index b70ee3c15ac..553aa871c38 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit3.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit3.ts
@@ -1,7 +1,7 @@
 //@target: ES6
 //@declaration: true
 class C {
-    [Symbol.isRegExp](x: number);
-    [Symbol.isRegExp](x: string);
-    [Symbol.isRegExp](x: any) { }
+    [Symbol.toPrimitive](x: number);
+    [Symbol.toPrimitive](x: string);
+    [Symbol.toPrimitive](x: any) { }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit4.ts b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit4.ts
index dde80577fa4..01c75fd05bf 100644
--- a/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit4.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolDeclarationEmit4.ts
@@ -1,6 +1,6 @@
 //@target: ES6
 //@declaration: true
 class C {
-    get [Symbol.isRegExp]() { return ""; }
-    set [Symbol.isRegExp](x) { }
+    get [Symbol.toPrimitive]() { return ""; }
+    set [Symbol.toPrimitive](x) { }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolProperty21.ts b/tests/cases/conformance/es6/Symbols/symbolProperty21.ts
index 52e84a00425..f72e93e23a4 100644
--- a/tests/cases/conformance/es6/Symbols/symbolProperty21.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolProperty21.ts
@@ -8,6 +8,6 @@ declare function foo<T, U>(p: I<T, U>): { t: T; u: U };
 
 foo({
     [Symbol.isConcatSpreadable]: "",
-    [Symbol.isRegExp]: 0,
+    [Symbol.toPrimitive]: 0,
     [Symbol.unscopables]: true
 });
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/Symbols/symbolProperty5.ts b/tests/cases/conformance/es6/Symbols/symbolProperty5.ts
index 84cb12a9de8..56afcda2ed1 100644
--- a/tests/cases/conformance/es6/Symbols/symbolProperty5.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolProperty5.ts
@@ -1,7 +1,7 @@
 //@target: ES6
 var x = {
     [Symbol.iterator]: 0,
-    [Symbol.isRegExp]() { },
+    [Symbol.toPrimitive]() { },
     get [Symbol.toStringTag]() {
         return 0;
     }
diff --git a/tests/cases/conformance/es6/Symbols/symbolProperty6.ts b/tests/cases/conformance/es6/Symbols/symbolProperty6.ts
index ff17b977c38..24515e92a56 100644
--- a/tests/cases/conformance/es6/Symbols/symbolProperty6.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolProperty6.ts
@@ -2,7 +2,7 @@
 class C {
     [Symbol.iterator] = 0;
     [Symbol.unscopables]: number;
-    [Symbol.isRegExp]() { }
+    [Symbol.toPrimitive]() { }
     get [Symbol.toStringTag]() {
         return 0;
     }
diff --git a/tests/cases/conformance/es6/Symbols/symbolProperty8.ts b/tests/cases/conformance/es6/Symbols/symbolProperty8.ts
index 14b4a32688f..19c6583777e 100644
--- a/tests/cases/conformance/es6/Symbols/symbolProperty8.ts
+++ b/tests/cases/conformance/es6/Symbols/symbolProperty8.ts
@@ -1,5 +1,5 @@
 //@target: ES6
 interface I {
     [Symbol.unscopables]: number;
-    [Symbol.isRegExp]();
+    [Symbol.toPrimitive]();
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts b/tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts
new file mode 100644
index 00000000000..d9fdcc167eb
--- /dev/null
+++ b/tests/cases/conformance/es6/classDeclaration/emitClassDeclarationWithSuperMethodCall01.ts
@@ -0,0 +1,12 @@
+//@target: es6
+
+class Parent {
+    foo() {
+    }
+}
+
+class Foo extends Parent {
+    foo() {
+        var x = () => super.foo();
+    }
+}
\ 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/conformance/parser/ecmascript6/Symbols/parserSymbolProperty4.ts b/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty4.ts
index 6a0962f15cb..efb5a6819b0 100644
--- a/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty4.ts
+++ b/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty4.ts
@@ -1,4 +1,4 @@
 //@target: ES6
 declare class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty5.ts b/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty5.ts
index 5f3fbaeaaea..629d7ce0126 100644
--- a/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty5.ts
+++ b/tests/cases/conformance/parser/ecmascript6/Symbols/parserSymbolProperty5.ts
@@ -1,4 +1,4 @@
 //@target: ES6
 class C {
-    [Symbol.isRegExp]: string;
+    [Symbol.toPrimitive]: string;
 }
\ No newline at end of file
diff --git a/tests/cases/fourslash/findAllRefsOnDecorators.ts b/tests/cases/fourslash/findAllRefsOnDecorators.ts
new file mode 100644
index 00000000000..3225bc108ce
--- /dev/null
+++ b/tests/cases/fourslash/findAllRefsOnDecorators.ts
@@ -0,0 +1,19 @@
+/// <reference path="fourslash.ts" />
+
+// @Filename: a.ts
+////function decorator(target) {
+////    return target;
+////}
+////decorator();
+
+// @Filename: b.ts
+////@deco/*1*/rator @decorator("again")
+////class C {
+////    @decorator
+////    method() {}
+////}
+
+goTo.file("b.ts");
+goTo.marker("1");
+
+verify.referencesCountIs(5);
\ No newline at end of file
diff --git a/tests/cases/fourslash/formattingDecorators.ts b/tests/cases/fourslash/formattingDecorators.ts
new file mode 100644
index 00000000000..366b9cb7729
--- /dev/null
+++ b/tests/cases/fourslash/formattingDecorators.ts
@@ -0,0 +1,106 @@
+/// <reference path='fourslash.ts' />
+
+/////*1*/        @    decorator1    
+/////*2*/            @        decorator2
+/////*3*/    @decorator3
+/////*4*/        @    decorator4    @            decorator5
+/////*5*/class C {
+/////*6*/            @    decorator6    
+/////*7*/                @        decorator7
+/////*8*/        @decorator8
+/////*9*/    method1() { }
+////
+/////*10*/        @    decorator9    @            decorator10 @decorator11            method2() { }
+////
+////    method3(
+/////*11*/                @    decorator12    
+/////*12*/                    @        decorator13
+/////*13*/            @decorator14
+/////*14*/        x) { }
+////
+////    method4(
+/////*15*/            @    decorator15    @            decorator16 @decorator17             x) { }
+////
+/////*16*/            @    decorator18    
+/////*17*/                @        decorator19
+/////*18*/        @decorator20    
+/////*19*/    ["computed1"]() { }
+////
+/////*20*/        @    decorator21    @            decorator22 @decorator23            ["computed2"]() { }
+////
+/////*21*/            @    decorator24    
+/////*22*/                @        decorator25
+/////*23*/        @decorator26
+/////*24*/    get accessor1() { }
+////
+/////*25*/        @    decorator27    @            decorator28 @decorator29            get accessor2() { }
+////
+/////*26*/            @    decorator30    
+/////*27*/                @        decorator31
+/////*28*/        @decorator32
+/////*29*/    property1;
+////
+/////*30*/        @    decorator33    @            decorator34 @decorator35            property2;
+////}
+
+format.document();
+goTo.marker("1");
+verify.currentLineContentIs("@decorator1");
+goTo.marker("2");
+verify.currentLineContentIs("@decorator2");
+goTo.marker("3");
+verify.currentLineContentIs("@decorator3");
+goTo.marker("4");
+verify.currentLineContentIs("@decorator4 @decorator5");
+goTo.marker("5");
+verify.currentLineContentIs("class C {");
+goTo.marker("6");
+verify.currentLineContentIs("    @decorator6");
+goTo.marker("7");
+verify.currentLineContentIs("    @decorator7");
+goTo.marker("8");
+verify.currentLineContentIs("    @decorator8");
+goTo.marker("9");
+verify.currentLineContentIs("    method1() { }");
+goTo.marker("10");
+verify.currentLineContentIs("    @decorator9 @decorator10 @decorator11 method2() { }");
+goTo.marker("11");
+verify.currentLineContentIs("        @decorator12");
+goTo.marker("12");
+verify.currentLineContentIs("        @decorator13");
+goTo.marker("13");
+verify.currentLineContentIs("        @decorator14");
+goTo.marker("14");
+verify.currentLineContentIs("        x) { }");
+goTo.marker("15");
+verify.currentLineContentIs("        @decorator15 @decorator16 @decorator17 x) { }");
+goTo.marker("16");
+verify.currentLineContentIs("    @decorator18");
+goTo.marker("17");
+verify.currentLineContentIs("    @decorator19");
+goTo.marker("18");
+verify.currentLineContentIs("    @decorator20");
+goTo.marker("19");
+verify.currentLineContentIs("    [\"computed1\"]() { }");
+goTo.marker("20");
+verify.currentLineContentIs("    @decorator21 @decorator22 @decorator23 [\"computed2\"]() { }");
+goTo.marker("21");
+verify.currentLineContentIs("    @decorator24");
+goTo.marker("22");
+verify.currentLineContentIs("    @decorator25");
+goTo.marker("23");
+verify.currentLineContentIs("    @decorator26");
+goTo.marker("24");
+verify.currentLineContentIs("    get accessor1() { }");
+goTo.marker("25");
+verify.currentLineContentIs("    @decorator27 @decorator28 @decorator29 get accessor2() { }");
+goTo.marker("26");
+verify.currentLineContentIs("    @decorator30");
+goTo.marker("27");
+verify.currentLineContentIs("    @decorator31");
+goTo.marker("28");
+verify.currentLineContentIs("    @decorator32");
+goTo.marker("29");
+verify.currentLineContentIs("    property1;");
+goTo.marker("30");
+verify.currentLineContentIs("    @decorator33 @decorator34 @decorator35 property2;");
\ No newline at end of file
diff --git a/tests/cases/fourslash/getOccurrencesOfDecorators.ts b/tests/cases/fourslash/getOccurrencesOfDecorators.ts
new file mode 100644
index 00000000000..207e6877d99
--- /dev/null
+++ b/tests/cases/fourslash/getOccurrencesOfDecorators.ts
@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: b.ts
+////@/*1*/decorator
+////class C {
+////    @decorator
+////    method() {}
+////}
+////function decorator(target) {
+////    return target;
+////}
+
+goTo.marker("1");
+verify.occurrencesAtPositionCount(3);
diff --git a/tests/cases/fourslash/getOutliningForBlockComments.ts b/tests/cases/fourslash/getOutliningForBlockComments.ts
new file mode 100644
index 00000000000..66838d0db75
--- /dev/null
+++ b/tests/cases/fourslash/getOutliningForBlockComments.ts
@@ -0,0 +1,105 @@
+/// <reference path="fourslash.ts"/>
+
+////[|/*
+////    Block comment at the beginning of the file before module:
+////        line one of the comment
+////        line two of the comment
+////        line three
+////        line four
+////        line five
+////*/|]
+////module Sayings[| {
+////    [|/*
+////    Comment before class:
+////        line one of the comment
+////        line two of the comment
+////        line three
+////        line four
+////        line five
+////    */|]
+////    export class Greeter[| {
+////        [|/*
+////            Comment before a string identifier
+////            line two of the comment
+////        */|]
+////        greeting: string;
+////        [|/*
+////            constructor
+////            parameter message as a string
+////        */|]
+////        
+////        [|/*
+////            Multiple comments should be collapsed individually
+////        */|]
+////        constructor(message: string /* do not collapse this */)[| {
+////            this.greeting = message;
+////        }|]
+////        [|/*
+////            method of a class
+////        */|]
+////        greet()[| {
+////            return "Hello, " + this.greeting;
+////        }|]
+////    }|]
+////}|]
+////
+////[|/*
+////    Block comment for interface. The ending can be on the same line as the declaration.
+////*/|]interface IFoo[| {
+////    [|/*
+////    Multiple block comments
+////    */|]
+////
+////    [|/*  
+////    should be collapsed
+////    */|]
+////
+////    [|/*
+////    individually
+////    */|]
+////
+////                                                                                                                              [|/*
+////                                                                    this comment has trailing space before /* and after *-/ signs
+////    */|]                                                                          
+////
+////    [|/**
+////     *
+////     *
+////     *
+////     */|]
+////
+////    [|/*
+////    */|]
+////
+////    [|/*
+////    */|]
+////    // single line comments in the middle should not have an effect
+////    [|/*
+////    */|]
+////
+////    [|/*
+////    */|]
+////
+////    [|/*
+////    this block comment ends     
+////    on the same line */|]  [|/* where the following comment starts
+////        should be collapsed separately
+////    */|]
+////
+////    getDist(): number;
+////}|]
+////
+////var x =[|{
+////  a:1,
+////  b: 2,
+////  [|/*
+////        Over a function in an object literal
+////  */|]
+////  get foo()[| {
+////    return 1;
+////  }|]
+////}|]
+
+verify.outliningSpansInCurrentFile(test.ranges());
+
+
diff --git a/tests/cases/fourslash/getOutliningForSingleLineComments.ts b/tests/cases/fourslash/getOutliningForSingleLineComments.ts
new file mode 100644
index 00000000000..903b1c55494
--- /dev/null
+++ b/tests/cases/fourslash/getOutliningForSingleLineComments.ts
@@ -0,0 +1,78 @@
+/// <reference path="fourslash.ts"/>
+
+////[|// Single line comments at the start of the file
+////// line 2
+////// line 3
+////// line 4|]
+////module Sayings[| {
+////
+////    [|/*
+////    */|]
+////    [|// A sequence of
+////    // single line|]
+////    [|/*
+////        and block
+////    */|]
+////    [|// comments
+////    //|]
+////    export class Sample[| {
+////    }|]
+////}|]
+////
+////interface IFoo[| {
+////    [|// all consecutive single line comments should be in one block regardless of their number or empty lines/spaces inbetween
+////
+////    // comment 2
+////    // comment 3
+////
+////    //comment 4
+////    /// comment 5
+////    ///// comment 6
+////
+////    //comment 7
+////    ///comment 8
+////    // comment 9
+////    // //comment 10
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////
+////    // // //comment 11
+////    // comment 12
+////    // comment 13
+////    // comment 14
+////    // comment 15
+////
+////    // comment 16
+////    // comment 17
+////    // comment 18
+////    // comment 19
+////    // comment 20    
+////    // comment 21|]
+////
+////    getDist(): number; // One single line comment should not be collapsed
+////}|]
+////
+////// One single line comment should not be collapsed
+////class WithOneSingleLineComment[| {
+////}|]
+
+verify.outliningSpansInCurrentFile(test.ranges());
+
+
diff --git a/tests/cases/fourslash/goToDefinitionDecorator.ts b/tests/cases/fourslash/goToDefinitionDecorator.ts
new file mode 100644
index 00000000000..b0899a9576c
--- /dev/null
+++ b/tests/cases/fourslash/goToDefinitionDecorator.ts
@@ -0,0 +1,26 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: b.ts
+////@/*decoratorUse*/decorator
+////class C {
+////    @decora/*decoratorFactoryUse*/torFactory(a, "22", true)
+////    method() {}
+////}
+
+
+// @Filename: a.ts
+/////*decoratorDefinition*/function decorator(target) {
+////    return target;
+////}
+/////*decoratorFactoryDefinition*/function decoratorFactory(...args) {
+////    return target => target;
+////}
+
+
+goTo.marker('decoratorUse');
+goTo.definition();
+verify.caretAtMarker('decoratorDefinition');
+
+goTo.marker('decoratorFactoryUse');
+goTo.definition();
+verify.caretAtMarker('decoratorFactoryDefinition');
diff --git a/tests/cases/fourslash/quickInfoForDecorators.ts b/tests/cases/fourslash/quickInfoForDecorators.ts
new file mode 100644
index 00000000000..14390f3c8ae
--- /dev/null
+++ b/tests/cases/fourslash/quickInfoForDecorators.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+////@/*1*/decorator
+////class C {
+
+////}
+/////** decorator documentation*/
+////var decorator = t=> t;
+
+goTo.marker("1");
+verify.quickInfoIs("var decorator: (t: any) => any", "decorator documentation");
\ 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 68%
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 79%
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 81%
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 72%
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) {
 ////}