diff --git a/package.json b/package.json
index ca137dcfb40e2..d6a8f538b78c6 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "http://typescriptlang.org/",
-    "version": "1.5.2",
+    "version": "1.5.3",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 528ee97602bdd..76ec977491ee2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -91,6 +91,9 @@ module ts {
         let circularType = createIntrinsicType(TypeFlags.Any, "__circular__");
 
         let emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        let emptyGenericType = <GenericType><ObjectType>createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        emptyGenericType.instantiations = {};
+
         let anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         let noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
 
@@ -99,19 +102,20 @@ module ts {
 
         let globals: SymbolTable = {};
 
-        let globalArraySymbol: Symbol;
         let globalESSymbolConstructorSymbol: Symbol;
 
         let globalObjectType: ObjectType;
         let globalFunctionType: ObjectType;
-        let globalArrayType: ObjectType;
+        let globalArrayType: GenericType;
         let globalStringType: ObjectType;
         let globalNumberType: ObjectType;
         let globalBooleanType: ObjectType;
         let globalRegExpType: ObjectType;
         let globalTemplateStringsArrayType: ObjectType;
         let globalESSymbolType: ObjectType;
-        let globalIterableType: ObjectType;
+        let globalIterableType: GenericType;
+        let globalIteratorType: GenericType;
+        let globalIterableIteratorType: GenericType;
 
         let anyArrayType: Type;
         let getGlobalClassDecoratorType: () => ObjectType;
@@ -2150,7 +2154,7 @@ module ts {
                 // checkRightHandSideOfForOf will return undefined if the for-of expression type was
                 // missing properties/signatures required to get its iteratedType (like
                 // [Symbol.iterator] or next). This may be because we accessed properties from anyType,
-                // or it may have led to an error inside getIteratedType.
+                // or it may have led to an error inside getElementTypeOfIterable.
                 return checkRightHandSideOfForOf((<ForOfStatement>declaration.parent.parent).expression) || anyType;
             }
             if (isBindingPattern(declaration.parent)) {
@@ -3473,16 +3477,16 @@ module ts {
             }
 
             if (!symbol) {
-                return emptyObjectType;
+                return arity ? emptyGenericType : emptyObjectType;
             }
             let type = getDeclaredTypeOfSymbol(symbol);
             if (!(type.flags & TypeFlags.ObjectType)) {
                 error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name);
-                return emptyObjectType;
+                return arity ? emptyGenericType : emptyObjectType;
             }
             if (((<InterfaceType>type).typeParameters ? (<InterfaceType>type).typeParameters.length : 0) !== arity) {
                 error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbol.name, arity);
-                return emptyObjectType;
+                return arity ? emptyGenericType : emptyObjectType;
             }
             return <ObjectType>type;
         }
@@ -3507,16 +3511,23 @@ module ts {
             return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol"));
         }
 
+        /**
+         * Instantiates a global type that is generic with some element type, and returns that instantiation.
+         */
+        function createTypeFromGenericGlobalType(genericGlobalType: GenericType, elementType: Type): Type {
+            return <ObjectType>genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, [elementType]) : emptyObjectType;
+        }
+
         function createIterableType(elementType: Type): Type {
-            return globalIterableType !== emptyObjectType ? createTypeReference(<GenericType>globalIterableType, [elementType]) : emptyObjectType;
+            return createTypeFromGenericGlobalType(globalIterableType, elementType);
+        }
+
+        function createIterableIteratorType(elementType: Type): Type {
+            return createTypeFromGenericGlobalType(globalIterableIteratorType, elementType);
         }
 
         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.
-            // We instead use globalArraySymbol to obtain the (not yet fully constructed) Array type.
-            let arrayType = globalArrayType || getDeclaredTypeOfSymbol(globalArraySymbol);
-            return arrayType !== emptyObjectType ? createTypeReference(<GenericType>arrayType, [elementType]) : emptyObjectType;
+            return createTypeFromGenericGlobalType(globalArrayType, elementType);
         }
 
         function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
@@ -5784,20 +5795,44 @@ module ts {
         }
 
         function getContextualTypeForReturnExpression(node: Expression): Type {
+            let func = getContainingFunction(node);
+            if (func && !func.asteriskToken) {
+                return getContextualReturnType(func);
+            }
+
+            return undefined;
+        }
+
+        function getContextualTypeForYieldOperand(node: YieldExpression): Type {
             let func = getContainingFunction(node);
             if (func) {
-                // If the containing function has a return type annotation, is a constructor, or is a get accessor whose
-                // corresponding set accessor has a type annotation, return statements in the function are contextually typed
-                if (func.type || func.kind === SyntaxKind.Constructor || func.kind === SyntaxKind.GetAccessor && getSetAccessorTypeAnnotationNode(<AccessorDeclaration>getDeclarationOfKind(func.symbol, SyntaxKind.SetAccessor))) {
-                    return getReturnTypeOfSignature(getSignatureFromDeclaration(func));
-                }
-                // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature
-                // and that call signature is non-generic, return statements are contextually typed by the return type of the signature
-                let signature = getContextualSignatureForFunctionLikeDeclaration(<FunctionExpression>func);
-                if (signature) {
-                    return getReturnTypeOfSignature(signature);
+                let contextualReturnType = getContextualReturnType(func);
+                if (contextualReturnType) {
+                    return node.asteriskToken
+                        ? contextualReturnType
+                        : getElementTypeOfIterableIterator(contextualReturnType);
                 }
             }
+
+            return undefined;
+        }
+
+        function getContextualReturnType(functionDecl: FunctionLikeDeclaration): Type {
+            // If the containing function has a return type annotation, is a constructor, or is a get accessor whose
+            // corresponding set accessor has a type annotation, return statements in the function are contextually typed
+            if (functionDecl.type ||
+                functionDecl.kind === SyntaxKind.Constructor ||
+                functionDecl.kind === SyntaxKind.GetAccessor && getSetAccessorTypeAnnotationNode(<AccessorDeclaration>getDeclarationOfKind(functionDecl.symbol, SyntaxKind.SetAccessor))) {
+                return getReturnTypeOfSignature(getSignatureFromDeclaration(functionDecl));
+            }
+
+            // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature
+            // and that call signature is non-generic, return statements are contextually typed by the return type of the signature
+            let signature = getContextualSignatureForFunctionLikeDeclaration(<FunctionExpression>functionDecl);
+            if (signature) {
+                return getReturnTypeOfSignature(signature);
+            }
+
             return undefined;
         }
 
@@ -5935,7 +5970,7 @@ module ts {
                 let index = indexOf(arrayLiteral.elements, node);
                 return getTypeOfPropertyOfContextualType(type, "" + index)
                     || getIndexTypeOfContextualType(type, IndexKind.Number)
-                    || (languageVersion >= ScriptTarget.ES6 ? checkIteratedType(type, /*expressionForError*/ undefined) : undefined);
+                    || (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(type, /*errorNode*/ undefined) : undefined);
             }
             return undefined;
         }
@@ -5967,6 +6002,8 @@ module ts {
                 case SyntaxKind.ArrowFunction:
                 case SyntaxKind.ReturnStatement:
                     return getContextualTypeForReturnExpression(node);
+                case SyntaxKind.YieldExpression:
+                    return getContextualTypeForYieldOperand(<YieldExpression>parent);
                 case SyntaxKind.CallExpression:
                 case SyntaxKind.NewExpression:
                     return getContextualTypeForArgument(<CallExpression>parent, node);
@@ -6006,8 +6043,10 @@ module ts {
         }
 
         function getContextualSignatureForFunctionLikeDeclaration(node: FunctionLikeDeclaration): Signature {
-            // Only function expressions and arrow functions are contextually typed.
-            return isFunctionExpressionOrArrowFunction(node) ? getContextualSignature(<FunctionExpression>node) : undefined;
+            // Only function expressions, arrow functions, and object literal methods are contextually typed.
+            return isFunctionExpressionOrArrowFunction(node) || isObjectLiteralMethod(node)
+                ? getContextualSignature(<FunctionExpression>node)
+                : undefined;
         }
 
         // Return the contextual signature for a given expression node. A contextual type provides a
@@ -6122,7 +6161,7 @@ module ts {
                     // if there is no index type / iterated type.
                     let restArrayType = checkExpression((<SpreadElementExpression>e).expression, contextualMapper);
                     let restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
-                        (languageVersion >= ScriptTarget.ES6 ? checkIteratedType(restArrayType, /*expressionForError*/ undefined) : undefined);
+                        (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
                     
                     if (restElementType) {
                         elementTypes.push(restElementType);
@@ -7316,17 +7355,42 @@ module ts {
                 type = checkExpressionCached(<Expression>func.body, contextualMapper);
             }
             else {
-                // Aggregate the types of expressions within all the return statements.
-                let types = checkAndAggregateReturnExpressionTypes(<Block>func.body, contextualMapper);
-                if (types.length === 0) {
-                    return voidType;
+                let types: Type[];
+                let funcIsGenerator = !!func.asteriskToken;
+                if (funcIsGenerator) {
+                    types = checkAndAggregateYieldOperandTypes(<Block>func.body, contextualMapper);
+                    if (types.length === 0) {
+                        let iterableIteratorAny = createIterableIteratorType(anyType);
+                        if (compilerOptions.noImplicitAny) {
+                            error(func.asteriskToken,
+                                Diagnostics.Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type, typeToString(iterableIteratorAny));
+                        }
+                        return iterableIteratorAny;
+                    }
+                }
+                else {
+                    types = checkAndAggregateReturnExpressionTypes(<Block>func.body, contextualMapper);
+                    if (types.length === 0) {
+                        return voidType;
+                    }
                 }
-                // When return statements are contextually typed we allow the return type to be a union type. Otherwise we require the
-                // return expressions to have a best common supertype.
+
+                // When yield/return statements are contextually typed we allow the return type to be a union type.
+                // Otherwise we require the yield/return expressions to have a best common supertype.
                 type = contextualSignature ? getUnionType(types) : getCommonSupertype(types);
                 if (!type) {
-                    error(func, Diagnostics.No_best_common_type_exists_among_return_expressions);
-                    return unknownType;
+                    if (funcIsGenerator) {
+                        error(func, Diagnostics.No_best_common_type_exists_among_yield_expressions);
+                        return createIterableIteratorType(unknownType);
+                    }
+                    else {
+                        error(func, Diagnostics.No_best_common_type_exists_among_return_expressions);
+                        return unknownType;
+                    }
+                }
+
+                if (funcIsGenerator) {
+                    type = createIterableIteratorType(type);
                 }
             }
             if (!contextualSignature) {
@@ -7335,7 +7399,28 @@ module ts {
             return getWidenedType(type);
         }
 
-        /// Returns a set of types relating to every return expression relating to a function block.
+        function checkAndAggregateYieldOperandTypes(body: Block, contextualMapper?: TypeMapper): Type[] {
+            let aggregatedTypes: Type[] = [];
+
+            forEachYieldExpression(body, yieldExpression => {
+                let expr = yieldExpression.expression;
+                if (expr) {
+                    let type = checkExpressionCached(expr, contextualMapper);
+
+                    if (yieldExpression.asteriskToken) {
+                        // A yield* expression effectively yields everything that its operand yields
+                        type = checkElementTypeOfIterable(type, yieldExpression.expression);
+                    }
+
+                    if (!contains(aggregatedTypes, type)) {
+                        aggregatedTypes.push(type);
+                    }
+                }
+            });
+
+            return aggregatedTypes;
+        }
+
         function checkAndAggregateReturnExpressionTypes(body: Block, contextualMapper?: TypeMapper): Type[] {
             let aggregatedTypes: Type[] = [];
 
@@ -7978,14 +8063,58 @@ module ts {
             }
         }
 
-        function checkYieldExpression(node: YieldExpression): void {
+        function isYieldExpressionInClass(node: YieldExpression): boolean {
+            let current: Node = node
+            let parent = node.parent;
+            while (parent) { 
+                if (isFunctionLike(parent) && current === (<FunctionLikeDeclaration>parent).body) {
+                    return false;
+                }
+                else if (current.kind === SyntaxKind.ClassDeclaration || current.kind === SyntaxKind.ClassExpression) {
+                    return true;
+                }
+
+                current = parent;
+                parent = parent.parent;
+            }
+
+            return false;
+        }
+
+        function checkYieldExpression(node: YieldExpression): Type {
             // Grammar checking
-            if (!(node.parserContextFlags & ParserContextFlags.Yield)) {
-                grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration);
+            if (!(node.parserContextFlags & ParserContextFlags.Yield) || isYieldExpressionInClass(node)) {
+                grammarErrorOnFirstToken(node, Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
             }
-            else {
-                grammarErrorOnFirstToken(node, Diagnostics.yield_expressions_are_not_currently_supported);
+
+            if (node.expression) {
+                let func = getContainingFunction(node);
+                // If the user's code is syntactically correct, the func should always have a star. After all,
+                // we are in a yield context.
+                if (func && func.asteriskToken) {
+                    let expressionType = checkExpressionCached(node.expression, /*contextualMapper*/ undefined);
+                    let expressionElementType: Type;
+                    let nodeIsYieldStar = !!node.asteriskToken;
+                    if (nodeIsYieldStar) {
+                        expressionElementType = checkElementTypeOfIterable(expressionType, node.expression);
+                    }
+                    // There is no point in doing an assignability check if the function
+                    // has no explicit return type because the return type is directly computed
+                    // from the yield expressions.
+                    if (func.type) {
+                        let signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType;
+                        if (nodeIsYieldStar) {
+                            checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined);
+                        }
+                        else {
+                            checkTypeAssignableTo(expressionType, signatureElementType, node.expression, /*headMessage*/ undefined);
+                        }
+                    }
+                }
             }
+
+            // Both yield and yield* expressions have type 'any'
+            return anyType;
         }
 
         function checkConditionalExpression(node: ConditionalExpression, contextualMapper?: TypeMapper): Type {
@@ -8175,8 +8304,7 @@ module ts {
                 case SyntaxKind.OmittedExpression:
                     return undefinedType;
                 case SyntaxKind.YieldExpression:
-                    checkYieldExpression(<YieldExpression>node);
-                    return unknownType;
+                    return checkYieldExpression(<YieldExpression>node);
             }
             return unknownType;
         }
@@ -8229,6 +8357,16 @@ module ts {
             }
         }
 
+        function isSyntacticallyValidGenerator(node: SignatureDeclaration): boolean {
+            if (!(<FunctionLikeDeclaration>node).asteriskToken || !(<FunctionLikeDeclaration>node).body) {
+                return false;
+            }
+
+            return node.kind === SyntaxKind.MethodDeclaration ||
+                node.kind === SyntaxKind.FunctionDeclaration ||
+                node.kind === SyntaxKind.FunctionExpression;
+        }
+
         function checkSignatureDeclaration(node: SignatureDeclaration) {
             // Grammar checking
             if (node.kind === SyntaxKind.IndexSignature) {
@@ -8261,6 +8399,27 @@ module ts {
                             break;
                     }
                 }
+
+                if (node.type) {
+                    if (languageVersion >= ScriptTarget.ES6 && isSyntacticallyValidGenerator(node)) {
+                        let returnType = getTypeFromTypeNode(node.type);
+                        if (returnType === voidType) {
+                            error(node.type, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+                        }
+                        else {
+                            let generatorElementType = getElementTypeOfIterableIterator(returnType) || anyType;
+                            let iterableIteratorInstantiation = createIterableIteratorType(generatorElementType);
+
+                            // Naively, one could check that IterableIterator<any> is assignable to the return type annotation.
+                            // However, that would not catch the error in the following case.
+                            //
+                            //    interface BadGenerator extends Iterable<number>, Iterator<string> { }
+                            //    function* g(): BadGenerator { } // Iterable and Iterator have different types!
+                            //
+                            checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type);
+                        }
+                    }
+                }
             }
 
             checkSpecializedSignatureDeclaration(node);
@@ -9032,10 +9191,19 @@ module ts {
                 checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type));
             }
 
-            // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
-            // in an ambient context
-            if (compilerOptions.noImplicitAny && nodeIsMissing(node.body) && !node.type && !isPrivateWithinAmbient(node)) {
-                reportImplicitAnyError(node, anyType);
+            if (produceDiagnostics && !node.type) {
+                // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
+                // in an ambient context
+                if (compilerOptions.noImplicitAny && nodeIsMissing(node.body) && !isPrivateWithinAmbient(node)) {
+                    reportImplicitAnyError(node, anyType);
+                }
+
+                if (node.asteriskToken && nodeIsPresent(node.body)) {
+                    // A generator with a body and no type annotation can still cause errors. It can error if the
+                    // yielded values have no common supertype, or it can give an implicit any error if it has no
+                    // yielded values. The only way to trigger these errors is to try checking its return type.
+                    getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+                }
             }
         }
 
@@ -9450,7 +9618,7 @@ module ts {
                     // iteratedType will be undefined if the rightType was missing properties/signatures
                     // required to get its iteratedType (like [Symbol.iterator] or next). This may be
                     // because we accessed properties from anyType, or it may have led to an error inside
-                    // getIteratedType.
+                    // getElementTypeOfIterable.
                     if (iteratedType) {
                         checkTypeAssignableTo(iteratedType, leftType, varExpr, /*headMessage*/ undefined);
                     }
@@ -9526,7 +9694,7 @@ module ts {
             }
 
             if (languageVersion >= ScriptTarget.ES6) {
-                return checkIteratedType(inputType, errorNode) || anyType;
+                return checkElementTypeOfIterable(inputType, errorNode);
             }
 
             if (allowStringInput) {
@@ -9547,100 +9715,143 @@ module ts {
         /**
          * When errorNode is undefined, it means we should not report any errors.
          */
-        function checkIteratedType(iterable: Type, errorNode: Node): Type {
-            Debug.assert(languageVersion >= ScriptTarget.ES6);
-            let iteratedType = getIteratedType(iterable, errorNode);
+        function checkElementTypeOfIterable(iterable: Type, errorNode: Node): Type {
+            let elementType = getElementTypeOfIterable(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 (errorNode && iteratedType) {
-                checkTypeAssignableTo(iterable, createIterableType(iteratedType), errorNode);
+            if (errorNode && elementType) {
+                checkTypeAssignableTo(iterable, createIterableType(elementType), errorNode);
             }
 
-            return iteratedType;
-
-            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):
-                //
-                // { // iterable
-                //     [Symbol.iterator]: { // iteratorFunction
-                //         (): { // iterator
-                //             next: { // iteratorNextFunction
-                //                 (): { // iteratorNextResult
-                //                     value: T // iteratorNextValue
-                //                 }
-                //             }
-                //         }
-                //     }
-                // }
-                //
-                // T is the type we are after. At every level that involves analyzing return types
-                // of signatures, we union the return types of all the signatures.
-                //
-                // Another thing to note is that at any step of this process, we could run into a dead end,
-                // meaning either the property is missing, or we run into the anyType. If either of these things
-                // happens, we return undefined to signal that we could not find the iterated type. If a property
-                // is missing, and the previous step did not result in 'any', then we also give an error if the
-                // caller requested it. Then the caller can decide what to do in the case where there is no iterated
-                // type. This is different from returning anyType, because that would signify that we have matched the
-                // whole pattern and that T (above) is 'any'.
-
-                if (allConstituentTypesHaveKind(iterable, TypeFlags.Any)) {
-                    return undefined;
-                }
+            return elementType || anyType;
+        }
+        
+        /**
+         * 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):
+         *
+         * { // iterable
+         *     [Symbol.iterator]: { // iteratorFunction
+         *         (): Iterator<T>
+         *     }
+         * }
+         *
+         * T is the type we are after. At every level that involves analyzing return types
+         * of signatures, we union the return types of all the signatures.
+         *
+         * Another thing to note is that at any step of this process, we could run into a dead end,
+         * meaning either the property is missing, or we run into the anyType. If either of these things
+         * happens, we return undefined to signal that we could not find the iterated type. If a property
+         * is missing, and the previous step did not result in 'any', then we also give an error if the
+         * caller requested it. Then the caller can decide what to do in the case where there is no iterated
+         * type. This is different from returning anyType, because that would signify that we have matched the
+         * whole pattern and that T (above) is 'any'.
+         */
+        function getElementTypeOfIterable(type: Type, errorNode: Node): Type {
+            if (type.flags & TypeFlags.Any) {
+                return undefined;
+            }
 
+            let typeAsIterable = <IterableOrIteratorType>type;
+            if (!typeAsIterable.iterableElementType) {
                 // 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;
+                if ((type.flags & TypeFlags.Reference) && (<GenericType>type).target === globalIterableType) {
+                    typeAsIterable.iterableElementType = (<GenericType>type).typeArguments[0];
                 }
+                else {
+                    let iteratorFunction = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator"));
+                    if (iteratorFunction && iteratorFunction.flags & TypeFlags.Any) {
+                        return undefined;
+                    }
 
-                let iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray;
-                if (iteratorFunctionSignatures.length === 0) {
-                    if (errorNode) {
-                        error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
+                    let iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray;
+                    if (iteratorFunctionSignatures.length === 0) {
+                        if (errorNode) {
+                            error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
+                        }
+                        return undefined;
                     }
-                    return undefined;
-                }
 
-                let iterator = getUnionType(map(iteratorFunctionSignatures, getReturnTypeOfSignature));
-                if (allConstituentTypesHaveKind(iterator, TypeFlags.Any)) {
-                    return undefined;
+                    typeAsIterable.iterableElementType = getElementTypeOfIterator(getUnionType(map(iteratorFunctionSignatures, getReturnTypeOfSignature)), errorNode);
                 }
+            }
 
-                let iteratorNextFunction = getTypeOfPropertyOfType(iterator, "next");
-                if (iteratorNextFunction && allConstituentTypesHaveKind(iteratorNextFunction, TypeFlags.Any)) {
-                    return undefined;
+            return typeAsIterable.iterableElementType;
+        }
+
+        /**
+         * This function has very similar logic as getElementTypeOfIterable, except that it operates on
+         * Iterators instead of Iterables. Here is the structure:
+         *
+         *  { // iterator
+         *      next: { // iteratorNextFunction
+         *          (): { // iteratorNextResult
+         *              value: T // iteratorNextValue
+         *          }
+         *      }
+         *  }
+         *
+         */
+        function getElementTypeOfIterator(type: Type, errorNode: Node): Type {
+            if (type.flags & TypeFlags.Any) {
+                return undefined;
+            }
+
+            let typeAsIterator = <IterableOrIteratorType>type;
+            if (!typeAsIterator.iteratorElementType) {
+                // As an optimization, if the type is instantiated directly using the globalIteratorType (Iterator<number>),
+                // then just grab its type argument.
+                if ((type.flags & TypeFlags.Reference) && (<GenericType>type).target === globalIteratorType) {
+                    typeAsIterator.iteratorElementType = (<GenericType>type).typeArguments[0];
                 }
+                else {
+                    let iteratorNextFunction = getTypeOfPropertyOfType(type, "next");
+                    if (iteratorNextFunction && iteratorNextFunction.flags & TypeFlags.Any) {
+                        return undefined;
+                    }
 
-                let iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray;
-                if (iteratorNextFunctionSignatures.length === 0) {
-                    if (errorNode) {
-                        error(errorNode, Diagnostics.An_iterator_must_have_a_next_method);
+                    let iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray;
+                    if (iteratorNextFunctionSignatures.length === 0) {
+                        if (errorNode) {
+                            error(errorNode, Diagnostics.An_iterator_must_have_a_next_method);
+                        }
+                        return undefined;
                     }
-                    return undefined;
-                }
 
-                let iteratorNextResult = getUnionType(map(iteratorNextFunctionSignatures, getReturnTypeOfSignature));
-                if (allConstituentTypesHaveKind(iteratorNextResult, TypeFlags.Any)) {
-                    return undefined;
-                }
+                    let iteratorNextResult = getUnionType(map(iteratorNextFunctionSignatures, getReturnTypeOfSignature));
+                    if (iteratorNextResult.flags & TypeFlags.Any) {
+                        return undefined;
+                    }
 
-                let iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
-                if (!iteratorNextValue) {
-                    if (errorNode) {
-                        error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
+                    let iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
+                    if (!iteratorNextValue) {
+                        if (errorNode) {
+                            error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
+                        }
+                        return undefined;
                     }
-                    return undefined;
+
+                    typeAsIterator.iteratorElementType = iteratorNextValue;
                 }
+            }
+
+            return typeAsIterator.iteratorElementType;
+        }
+
+        function getElementTypeOfIterableIterator(type: Type): Type {
+            if (type.flags & TypeFlags.Any) {
+                return undefined;
+            }
 
-                return iteratorNextValue;
+            // As an optimization, if the type is instantiated directly using the globalIterableIteratorType (IterableIterator<number>),
+            // then just grab its type argument.
+            if ((type.flags & TypeFlags.Reference) && (<GenericType>type).target === globalIterableIteratorType) {
+                return (<GenericType>type).typeArguments[0];
             }
+
+            return getElementTypeOfIterable(type, /*errorNode*/ undefined) ||
+                getElementTypeOfIterator(type, /*errorNode*/ undefined);
         }
 
         /**
@@ -9734,19 +9945,26 @@ module ts {
                 if (func) {
                     let returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
                     let exprType = checkExpressionCached(node.expression);
+                    
+                    if (func.asteriskToken) {
+                        // A generator does not need its return expressions checked against its return type.
+                        // Instead, the yield expressions are checked against the element type.
+                        // TODO: Check return expressions of generators when return type tracking is added
+                        // for generators.
+                        return;
+                    }
+
                     if (func.kind === SyntaxKind.SetAccessor) {
                         error(node.expression, Diagnostics.Setters_cannot_return_a_value);
                     }
-                    else {
-                        if (func.kind === SyntaxKind.Constructor) {
-                            if (!isTypeAssignableTo(exprType, returnType)) {
-                                error(node.expression, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
-                            }
-                        }
-                        else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) {
-                            checkTypeAssignableTo(exprType, returnType, node.expression, /*headMessage*/ undefined);
+                    else if (func.kind === SyntaxKind.Constructor) {
+                        if (!isTypeAssignableTo(exprType, returnType)) {
+                            error(node.expression, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
                         }
                     }
+                    else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func)) {
+                        checkTypeAssignableTo(exprType, returnType, node.expression, /*headMessage*/ undefined);
+                    }
                 }
             }
         }
@@ -11227,93 +11445,6 @@ module ts {
             return node.parent && node.parent.kind === SyntaxKind.ExpressionWithTypeArguments;
         }
 
-        function isTypeNode(node: Node): boolean {
-            if (SyntaxKind.FirstTypeNode <= node.kind && node.kind <= SyntaxKind.LastTypeNode) {
-                return true;
-            }
-
-            switch (node.kind) {
-                case SyntaxKind.AnyKeyword:
-                case SyntaxKind.NumberKeyword:
-                case SyntaxKind.StringKeyword:
-                case SyntaxKind.BooleanKeyword:
-                case SyntaxKind.SymbolKeyword:
-                    return true;
-                case SyntaxKind.VoidKeyword:
-                    return node.parent.kind !== SyntaxKind.VoidExpression;
-                case SyntaxKind.StringLiteral:
-                    // Specialized signatures can have string literals as their parameters' type names
-                    return node.parent.kind === SyntaxKind.Parameter;
-                case SyntaxKind.ExpressionWithTypeArguments:
-                    return true;
-
-                // Identifiers and qualified names may be type nodes, depending on their context. Climb
-                // above them to find the lowest container
-                case SyntaxKind.Identifier:
-                    // If the identifier is the RHS of a qualified name, then it's a type iff its parent is.
-                    if (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) {
-                        node = node.parent;
-                    }
-                    else if (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node) {
-                        node = node.parent;
-                    }
-                    // fall through
-                case SyntaxKind.QualifiedName:
-                case SyntaxKind.PropertyAccessExpression:
-                    // At this point, node is either a qualified name or an identifier
-                    Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression,
-                        "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'.");
-
-                    let parent = node.parent;
-                    if (parent.kind === SyntaxKind.TypeQuery) {
-                        return false;
-                    }
-                    // Do not recursively call isTypeNode on the parent. In the example:
-                    //
-                    //     let a: A.B.C;
-                    //
-                    // Calling isTypeNode would consider the qualified name A.B a type node. Only C or
-                    // A.B.C is a type node.
-                    if (SyntaxKind.FirstTypeNode <= parent.kind && parent.kind <= SyntaxKind.LastTypeNode) {
-                        return true;
-                    }
-                    switch (parent.kind) {
-                        case SyntaxKind.ExpressionWithTypeArguments:
-                            return true;
-                        case SyntaxKind.TypeParameter:
-                            return node === (<TypeParameterDeclaration>parent).constraint;
-                        case SyntaxKind.PropertyDeclaration:
-                        case SyntaxKind.PropertySignature:
-                        case SyntaxKind.Parameter:
-                        case SyntaxKind.VariableDeclaration:
-                            return node === (<VariableLikeDeclaration>parent).type;
-                        case SyntaxKind.FunctionDeclaration:
-                        case SyntaxKind.FunctionExpression:
-                        case SyntaxKind.ArrowFunction:
-                        case SyntaxKind.Constructor:
-                        case SyntaxKind.MethodDeclaration:
-                        case SyntaxKind.MethodSignature:
-                        case SyntaxKind.GetAccessor:
-                        case SyntaxKind.SetAccessor:
-                            return node === (<FunctionLikeDeclaration>parent).type;
-                        case SyntaxKind.CallSignature:
-                        case SyntaxKind.ConstructSignature:
-                        case SyntaxKind.IndexSignature:
-                            return node === (<SignatureDeclaration>parent).type;
-                        case SyntaxKind.TypeAssertionExpression:
-                            return node === (<TypeAssertion>parent).type;
-                        case SyntaxKind.CallExpression:
-                        case SyntaxKind.NewExpression:
-                            return (<CallExpression>parent).typeArguments && indexOf((<CallExpression>parent).typeArguments, node) >= 0;
-                        case SyntaxKind.TaggedTemplateExpression:
-                            // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments.
-                            return false;
-                    }
-            }
-
-            return false;
-        }
-
         function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide: EntityName): ImportEqualsDeclaration | ExportAssignment {
             while (nodeOnRightSide.parent.kind === SyntaxKind.QualifiedName) {
                 nodeOnRightSide = <QualifiedName>nodeOnRightSide.parent;
@@ -12048,8 +12179,7 @@ module ts {
             getSymbolLinks(unknownSymbol).type = unknownType;
             globals[undefinedSymbol.name] = undefinedSymbol;
             // Initialize special types
-            globalArraySymbol = getGlobalTypeSymbol("Array");
-            globalArrayType = getTypeOfGlobalSymbol(globalArraySymbol, /*arity*/ 1);
+            globalArrayType = <GenericType>getGlobalType("Array", /*arity*/ 1);
             globalObjectType = getGlobalType("Object");
             globalFunctionType = getGlobalType("Function");
             globalStringType = getGlobalType("String");
@@ -12067,7 +12197,9 @@ module ts {
                 globalTemplateStringsArrayType = getGlobalType("TemplateStringsArray");
                 globalESSymbolType = getGlobalType("Symbol");
                 globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol");
-                globalIterableType = getGlobalType("Iterable", /*arity*/ 1);
+                globalIterableType = <GenericType>getGlobalType("Iterable", /*arity*/ 1);
+                globalIteratorType = <GenericType>getGlobalType("Iterator", /*arity*/ 1);
+                globalIterableIteratorType = <GenericType>getGlobalType("IterableIterator", /*arity*/ 1);
             }
             else {
                 globalTemplateStringsArrayType = unknownType;
@@ -12077,6 +12209,9 @@ module ts {
                 // a global Symbol already, particularly if it is a class.
                 globalESSymbolType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
                 globalESSymbolConstructorSymbol = undefined;
+                globalIterableType = emptyGenericType;
+                globalIteratorType = emptyGenericType;
+                globalIterableIteratorType = emptyGenericType;
             }
 
             anyArrayType = createArrayType(anyType);
@@ -12624,7 +12759,19 @@ module ts {
 
         function checkGrammarForGenerator(node: FunctionLikeDeclaration) {
             if (node.asteriskToken) {
-                return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_not_currently_supported);
+                Debug.assert(
+                    node.kind === SyntaxKind.FunctionDeclaration ||
+                    node.kind === SyntaxKind.FunctionExpression ||
+                    node.kind === SyntaxKind.MethodDeclaration);
+                if (isInAmbientContext(node)) {
+                    return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
+                }
+                if (!node.body) {
+                    return grammarErrorOnNode(node.asteriskToken, Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
+                }
+                if (languageVersion < ScriptTarget.ES6) {
+                    return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_only_available_when_targeting_ECMAScript_6_or_higher);
+                }
             }
         }
 
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index 61a55dde55abc..7e761dbb8a3ec 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -120,7 +120,7 @@ module ts {
         Unterminated_template_literal: { code: 1160, category: DiagnosticCategory.Error, key: "Unterminated template literal." },
         Unterminated_regular_expression_literal: { code: 1161, category: DiagnosticCategory.Error, key: "Unterminated regular expression literal." },
         An_object_member_cannot_be_declared_optional: { code: 1162, category: DiagnosticCategory.Error, key: "An object member cannot be declared optional." },
-        yield_expression_must_be_contained_within_a_generator_declaration: { code: 1163, category: DiagnosticCategory.Error, key: "'yield' expression must be contained_within a generator declaration." },
+        A_yield_expression_is_only_allowed_in_a_generator_body: { code: 1163, category: DiagnosticCategory.Error, key: "A 'yield' expression is only allowed in a generator body." },
         Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums." },
         A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol: { code: 1165, category: DiagnosticCategory.Error, key: "A computed property name in an ambient context must directly refer to a built-in symbol." },
         A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol: { code: 1166, category: DiagnosticCategory.Error, key: "A computed property name in a class property declaration must directly refer to a built-in symbol." },
@@ -174,6 +174,9 @@ module ts {
         Type_expected_0_is_a_reserved_word_in_strict_mode: { code: 1215, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode" },
         Type_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1216, category: DiagnosticCategory.Error, key: "Type expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." },
         Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." },
+        Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1219, category: DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." },
+        Generators_are_not_allowed_in_an_ambient_context: { code: 1220, category: DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." },
+        An_overload_signature_cannot_be_declared_as_a_generator: { code: 1221, category: DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." },
         _0_tag_already_specified: { code: 1219, category: DiagnosticCategory.Error, key: "'{0}' tag already specified." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
@@ -366,6 +369,8 @@ module ts {
         A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." },
         _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own type annotation." },
         Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." },
+        No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." },
+        A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
@@ -523,6 +528,7 @@ module ts {
         _0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: DiagnosticCategory.Error, key: "'{0}' implicitly has type 'any' because it is does not have a type annotation and is referenced directly or indirectly in its own initializer." },
         _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7023, category: DiagnosticCategory.Error, key: "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
         Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: DiagnosticCategory.Error, key: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
+        Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: DiagnosticCategory.Error, key: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
         You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." },
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." },
         import_can_only_be_used_in_a_ts_file: { code: 8002, category: DiagnosticCategory.Error, key: "'import ... =' can only be used in a .ts file." },
@@ -540,8 +546,6 @@ module ts {
         enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." },
         type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." },
         decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." },
-        yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported." },
-        Generators_are_not_currently_supported: { code: 9001, category: DiagnosticCategory.Error, key: "Generators are not currently supported." },
         Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },
         class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." },
         class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration: { code: 9004, category: DiagnosticCategory.Error, key: "'class' declarations are only supported directly inside a module or as a top level declaration." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index a4d7e3168d73e..76702f0d0e717 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -467,7 +467,7 @@
         "category": "Error",
         "code": 1162
     },
-    "'yield' expression must be contained_within a generator declaration.": {
+    "A 'yield' expression is only allowed in a generator body.": {
         "category": "Error",
         "code": 1163
     },
@@ -682,7 +682,21 @@
     "Export assignment is not supported when '--module' flag is 'system'.": {
         "category": "Error",
         "code": 1218
+    },    
+    "Generators are only available when targeting ECMAScript 6 or higher.": {
+        "category": "Error",
+        "code": 1219
     },
+    "Generators are not allowed in an ambient context.": {
+        "category": "Error",
+        "code": 1220
+    },
+    "An overload signature cannot be declared as a generator.": {
+        "category": "Error",
+        "code": 1221
+    },
+
+
     "'{0}' tag already specified.": {
         "category": "Error",
         "code": 1219
@@ -1442,15 +1456,23 @@
     "A rest element cannot contain a binding pattern.": {
         "category": "Error",
         "code": 2501
-    },
+    },
     "'{0}' is referenced directly or indirectly in its own type annotation.": {
         "category": "Error",
         "code": 2502
-    },
+    },
     "Cannot find namespace '{0}'.": {
         "category": "Error",
         "code": 2503
+    },
+    "No best common type exists among yield expressions.": {
+        "category": "Error",
+        "code": 2504
     },
+    "A generator cannot have a 'void' type annotation.": {
+        "category": "Error",
+        "code": 2505
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -2083,6 +2105,10 @@
         "category": "Error",
         "code": 7024
     },
+    "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type.": {
+        "category": "Error",
+        "code": 7025
+    },
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000
@@ -2152,14 +2178,6 @@
         "code": 8017
     },
 
-    "'yield' expressions are not currently supported.": {
-        "category": "Error",
-        "code": 9000
-    },
-    "Generators are not currently supported.": {
-        "category": "Error",
-        "code": 9001
-    },
     "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.": {
         "category": "Error",
         "code": 9002
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 28fd8184d7e81..d6d6f0d14daec 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -4143,7 +4143,20 @@ module ts {
             property.name = name;
             property.questionToken = questionToken;
             property.type = parseTypeAnnotation();
-            property.initializer = allowInAnd(parseNonParameterInitializer);
+
+            // For instance properties specifically, since they are evaluated inside the constructor,
+            // we do *not * want to parse yield expressions, so we specifically turn the yield context
+            // off. The grammar would look something like this:
+            //
+            //    MemberVariableDeclaration[Yield]:
+            //        AccessibilityModifier_opt   PropertyName   TypeAnnotation_opt   Initialiser_opt[In];
+            //        AccessibilityModifier_opt  static_opt  PropertyName   TypeAnnotation_opt   Initialiser_opt[In, ?Yield];
+            //
+            // The checker may still error in the static case to explicitly disallow the yield expression.
+            property.initializer = modifiers && modifiers.flags & NodeFlags.Static
+                ? allowInAnd(parseNonParameterInitializer)
+                : doOutsideOfContext(ParserContextFlags.Yield | ParserContextFlags.DisallowIn, parseNonParameterInitializer);
+
             parseSemicolon();
             return finishNode(property);
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 85fa461daab7c..3d52d096b0324 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -693,7 +693,7 @@ module ts {
 
     export interface YieldExpression extends Expression {
         asteriskToken?: Node;
-        expression: Expression;
+        expression?: Expression;
     }
 
     export interface BinaryExpression extends Expression {
@@ -1676,6 +1676,13 @@ module ts {
         numberIndexType: Type;             // Numeric index type
     }
 
+    // Just a place to cache element types of iterables and iterators
+    /* @internal */
+    export interface IterableOrIteratorType extends ObjectType, UnionType {
+        iterableElementType?: Type;
+        iteratorElementType?: Type;
+    }
+
     // Type parameters (TypeFlags.TypeParameter)
     export interface TypeParameter extends Type {
         constraint: Type;        // Constraint
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 4aca0859ceeef..5198d8a228811 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -408,6 +408,93 @@ module ts {
 
     export let fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/
 
+    export function isTypeNode(node: Node): boolean {
+        if (SyntaxKind.FirstTypeNode <= node.kind && node.kind <= SyntaxKind.LastTypeNode) {
+            return true;
+        }
+
+        switch (node.kind) {
+            case SyntaxKind.AnyKeyword:
+            case SyntaxKind.NumberKeyword:
+            case SyntaxKind.StringKeyword:
+            case SyntaxKind.BooleanKeyword:
+            case SyntaxKind.SymbolKeyword:
+                return true;
+            case SyntaxKind.VoidKeyword:
+                return node.parent.kind !== SyntaxKind.VoidExpression;
+            case SyntaxKind.StringLiteral:
+                // Specialized signatures can have string literals as their parameters' type names
+                return node.parent.kind === SyntaxKind.Parameter;
+            case SyntaxKind.ExpressionWithTypeArguments:
+                return true;
+
+            // Identifiers and qualified names may be type nodes, depending on their context. Climb
+            // above them to find the lowest container
+            case SyntaxKind.Identifier:
+                // If the identifier is the RHS of a qualified name, then it's a type iff its parent is.
+                if (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) {
+                    node = node.parent;
+                }
+                else if (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node) {
+                    node = node.parent;
+                }
+            // fall through
+            case SyntaxKind.QualifiedName:
+            case SyntaxKind.PropertyAccessExpression:
+                // At this point, node is either a qualified name or an identifier
+                Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression,
+                    "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'.");
+
+                let parent = node.parent;
+                if (parent.kind === SyntaxKind.TypeQuery) {
+                    return false;
+                }
+                // Do not recursively call isTypeNode on the parent. In the example:
+                //
+                //     let a: A.B.C;
+                //
+                // Calling isTypeNode would consider the qualified name A.B a type node. Only C or
+                // A.B.C is a type node.
+                if (SyntaxKind.FirstTypeNode <= parent.kind && parent.kind <= SyntaxKind.LastTypeNode) {
+                    return true;
+                }
+                switch (parent.kind) {
+                    case SyntaxKind.ExpressionWithTypeArguments:
+                        return true;
+                    case SyntaxKind.TypeParameter:
+                        return node === (<TypeParameterDeclaration>parent).constraint;
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.PropertySignature:
+                    case SyntaxKind.Parameter:
+                    case SyntaxKind.VariableDeclaration:
+                        return node === (<VariableLikeDeclaration>parent).type;
+                    case SyntaxKind.FunctionDeclaration:
+                    case SyntaxKind.FunctionExpression:
+                    case SyntaxKind.ArrowFunction:
+                    case SyntaxKind.Constructor:
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.MethodSignature:
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.SetAccessor:
+                        return node === (<FunctionLikeDeclaration>parent).type;
+                    case SyntaxKind.CallSignature:
+                    case SyntaxKind.ConstructSignature:
+                    case SyntaxKind.IndexSignature:
+                        return node === (<SignatureDeclaration>parent).type;
+                    case SyntaxKind.TypeAssertionExpression:
+                        return node === (<TypeAssertion>parent).type;
+                    case SyntaxKind.CallExpression:
+                    case SyntaxKind.NewExpression:
+                        return (<CallExpression>parent).typeArguments && indexOf((<CallExpression>parent).typeArguments, node) >= 0;
+                    case SyntaxKind.TaggedTemplateExpression:
+                        // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments.
+                        return false;
+                }
+        }
+
+        return false;
+    }
+
     // Warning: This has the same semantics as the forEach family of functions,
     //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
     export function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {
@@ -438,6 +525,46 @@ module ts {
         }
     }
 
+    export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpression) => void): void {
+
+        return traverse(body);
+
+        function traverse(node: Node): void {
+            switch (node.kind) {
+                case SyntaxKind.YieldExpression:
+                    visitor(<YieldExpression>node);
+                    let operand = (<YieldExpression>node).expression;
+                    if (operand) {
+                        traverse(operand);
+                    }
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.TypeAliasDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                    // These are not allowed inside a generator now, but eventually they may be allowed
+                    // as local types. Regardless, any yield statements contained within them should be
+                    // skipped in this traversal.
+                    return;
+                default:
+                    if (isFunctionLike(node)) {
+                        let name = (<FunctionLikeDeclaration>node).name;
+                        if (name && name.kind === SyntaxKind.ComputedPropertyName) {
+                            // Note that we will not include methods/accessors of a class because they would require
+                            // first descending into the class. This is by design.
+                            traverse((<ComputedPropertyName>name).expression);
+                            return;
+                        }
+                    }
+                    else if (!isTypeNode(node)) {
+                        // This is the general case, which should include mostly expressions and statements.
+                        // Also includes NodeArrays.
+                        forEachChild(node, traverse);
+                    }
+            }
+        }
+    }
+
     export function isVariableLike(node: Node): boolean {
         if (node) {
             switch (node.kind) {
@@ -739,6 +866,7 @@ module ts {
             case SyntaxKind.TemplateExpression:
             case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.OmittedExpression:
+            case SyntaxKind.YieldExpression:
                 return true;
             case SyntaxKind.QualifiedName:
                 while (node.parent.kind === SyntaxKind.QualifiedName) {
diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index 1403efae348ab..625a4eca9e138 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -505,14 +505,6 @@ interface GeneratorFunctionConstructor {
 }
 declare var GeneratorFunction: GeneratorFunctionConstructor;
 
-interface Generator<T> extends IterableIterator<T> {
-    next(value?: any): IteratorResult<T>;
-    throw(exception: any): IteratorResult<T>;
-    return(value: T): IteratorResult<T>;
-    [Symbol.iterator](): Generator<T>;
-    [Symbol.toStringTag]: string;
-}
-
 interface Math {
     /**
       * Returns the number of leading zero bits in the 32-bit binary representation of a number.
diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts
index 4686616c3cc58..9cf6d8ff4bcea 100644
--- a/src/services/formatting/rules.ts
+++ b/src/services/formatting/rules.ts
@@ -193,12 +193,18 @@ module ts.formatting {
         // Insert space after function keyword for anonymous functions
         public SpaceAfterAnonymousFunctionKeyword: Rule;
         public NoSpaceAfterAnonymousFunctionKeyword: Rule;
-
+        
         // Insert space after @ in decorator
         public SpaceBeforeAt: Rule;
         public NoSpaceAfterAt: Rule;
         public SpaceAfterDecorator: Rule;
 
+        // Generator: function*
+        public NoSpaceBetweenFunctionKeywordAndStar: Rule;
+        public SpaceAfterStarInGeneratorDeclaration: Rule;
+        public NoSpaceBetweenYieldKeywordAndStar: Rule;
+        public SpaceBetweenYieldOrYieldStarAndOperand: Rule;
+
         constructor() {
             ///
             /// Common Rules
@@ -340,6 +346,11 @@ module ts.formatting {
             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));
 
+            this.NoSpaceBetweenFunctionKeywordAndStar = new Rule(RuleDescriptor.create1(SyntaxKind.FunctionKeyword, SyntaxKind.AsteriskToken), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), RuleAction.Delete));
+            this.SpaceAfterStarInGeneratorDeclaration = new Rule(RuleDescriptor.create3(SyntaxKind.AsteriskToken, Shared.TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.OpenParenToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclarationOrFunctionExpressionContext), RuleAction.Space));
+            this.NoSpaceBetweenYieldKeywordAndStar = new Rule(RuleDescriptor.create1(SyntaxKind.YieldKeyword, SyntaxKind.AsteriskToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), RuleAction.Delete));
+            this.SpaceBetweenYieldOrYieldStarAndOperand = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.YieldKeyword, SyntaxKind.AsteriskToken]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), RuleAction.Space));
+
             // These rules are higher in priority than user-configurable rules.
             this.HighPriorityCommonRules =
             [
@@ -357,7 +368,9 @@ module ts.formatting {
                 this.NoSpaceAfterCloseBrace,
                 this.SpaceAfterOpenBrace, this.SpaceBeforeCloseBrace, this.NewLineBeforeCloseBraceInBlockContext,
                 this.SpaceAfterCloseBrace, this.SpaceBetweenCloseBraceAndElse, this.SpaceBetweenCloseBraceAndWhile, this.NoSpaceBetweenEmptyBraceBrackets,
+                this.NoSpaceBetweenFunctionKeywordAndStar, this.SpaceAfterStarInGeneratorDeclaration,
                 this.SpaceAfterFunctionInFuncDecl, this.NewLineAfterOpenBraceInBlockContext, this.SpaceAfterGetSetInMember,
+                this.NoSpaceBetweenYieldKeywordAndStar, this.SpaceBetweenYieldOrYieldStarAndOperand,
                 this.NoSpaceBetweenReturnAndSemicolon,
                 this.SpaceAfterCertainKeywords,
                 this.SpaceAfterLetConstInVariableDeclaration,
@@ -574,6 +587,10 @@ module ts.formatting {
             return false;
         }
 
+        static IsFunctionDeclarationOrFunctionExpressionContext(context: FormattingContext): boolean {
+            return context.contextNode.kind === SyntaxKind.FunctionDeclaration || context.contextNode.kind === SyntaxKind.FunctionExpression;
+        }
+
         static IsTypeScriptDeclWithBlockContext(context: FormattingContext): boolean {
             return Rules.NodeIsTypeScriptDeclWithBlockContext(context.contextNode);
         }
@@ -717,5 +734,9 @@ module ts.formatting {
         static IsVoidOpContext(context: FormattingContext): boolean {
             return context.currentTokenSpan.kind === SyntaxKind.VoidKeyword && context.currentTokenParent.kind === SyntaxKind.VoidExpression;
         }
+
+        static IsYieldOrYieldStarWithOperand(context: FormattingContext): boolean {
+            return context.contextNode.kind === SyntaxKind.YieldExpression && (<YieldExpression>context.contextNode).expression !== undefined;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/services/shims.ts b/src/services/shims.ts
index 27c70ddc878a4..d3f5973753850 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -989,4 +989,4 @@ module TypeScript.Services {
 }
 
 /* @internal */
-let toolsVersion = "1.4";
+let toolsVersion = "1.5";
diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt
index 8c6b09c82d6bd..c0a45a2be52ab 100644
--- a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,10): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,10): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (1 errors) ====
     function * foo(a = yield => yield) {
              ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt
index 1dd8c3f6a1ba8..2c674a63f938d 100644
--- a/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts (1 errors) ====
     function * yield() {
              ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
index a46097e8a1a5c..aeb9e1fa6a689 100644
--- a/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'yield'.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (2 errors) ====
     function * foo() {
              ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
        // Legal to use 'yield' in a type context.
        var v: yield;
               ~~~~~
diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt
index 71b099839391f..e3601968a274d 100644
--- a/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts (1 errors) ====
     function * foo() {
              ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
index b5ea3f494a74b..27981b028edd7 100644
--- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2304: Cannot find name 'yield'.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ====
     function*foo(a = yield) {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
                      ~~~~~
 !!! error TS2304: Cannot find name 'yield'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
index f129d3fa30b45..45e88ed7efbc6 100644
--- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
@@ -1,16 +1,16 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2304: Cannot find name 'yield'.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ====
     function*bar() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       // 'yield' here is an identifier, and not a yield expression.
       function*foo(a = yield) {
               ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
                        ~~~~~
 !!! error TS2304: Cannot find name 'yield'.
       }
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
index 152b1ffc7cc1f..b17b945e2f465 100644
--- a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(2,14): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (1 errors) ====
     function * foo() {
              ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       var v = { [yield]: foo }
-                 ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionExpression1_es6.errors.txt b/tests/baselines/reference/FunctionExpression1_es6.errors.txt
index 979178fd4b7bb..0bc04c8086096 100644
--- a/tests/baselines/reference/FunctionExpression1_es6.errors.txt
+++ b/tests/baselines/reference/FunctionExpression1_es6.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts (1 errors) ====
     var v = function * () { }
                      ~
-!!! error TS9001: Generators are not currently supported.
\ No newline at end of file
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionExpression2_es6.errors.txt b/tests/baselines/reference/FunctionExpression2_es6.errors.txt
index ab27947d7c543..e58fe7ab4c7ab 100644
--- a/tests/baselines/reference/FunctionExpression2_es6.errors.txt
+++ b/tests/baselines/reference/FunctionExpression2_es6.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts (1 errors) ====
     var v = function * foo() { }
                      ~
-!!! error TS9001: Generators are not currently supported.
\ No newline at end of file
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt b/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt
index bbabbc9746346..ebbc2a4dbe196 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt
+++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts (1 errors) ====
     var v = { *foo() { } }
               ~
-!!! error TS9001: Generators are not currently supported.
\ No newline at end of file
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
index 596764e58ea83..b2b071ee5e6e9 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
+++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,13): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (2 errors) ====
     var v = { *[foo()]() { } }
               ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
                 ~~~
 !!! error TS2304: Cannot find name 'foo'.
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt
index 9d4e312ed226b..0da724d7ec338 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt
+++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts (1 errors) ====
     class C {
        *foo() { }
        ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt
index 6373c80099458..8801b74cae5fc 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt
+++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts (1 errors) ====
     class C {
        public * foo() { }
               ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
index 826c1d7fd7541..458a3da62bb1f 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
+++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,6): error TS2304: Cannot find name 'foo'.
 
 
@@ -6,7 +6,7 @@ tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration
     class C {
        *[foo]() { }
        ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
          ~~~
 !!! error TS2304: Cannot find name 'foo'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt
index ea87da50ed314..210485e629f22 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt
+++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
 ==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts (1 errors) ====
     class C {
        *foo<T>() { }
        ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression10_es6.errors.txt b/tests/baselines/reference/YieldExpression10_es6.errors.txt
index e0d7ea4ad27c4..a4bf2a8eb8f9f 100644
--- a/tests/baselines/reference/YieldExpression10_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression10_es6.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(2,5): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(2,11): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (2 errors) ====
     var v = { * foo() {
               ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
         yield(foo);
-        ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
+              ~~~
+!!! error TS2304: Cannot find name 'foo'.
       }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression11_es6.errors.txt b/tests/baselines/reference/YieldExpression11_es6.errors.txt
index 3f322a81f2fd2..1272295fe5f12 100644
--- a/tests/baselines/reference/YieldExpression11_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression11_es6.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,5): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,11): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (2 errors) ====
     class C {
       *foo() {
       ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
         yield(foo);
-        ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
+              ~~~
+!!! error TS2304: Cannot find name 'foo'.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression12_es6.errors.txt b/tests/baselines/reference/YieldExpression12_es6.errors.txt
index 10843421a3f4a..42d447ed5d60f 100644
--- a/tests/baselines/reference/YieldExpression12_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression12_es6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts (1 errors) ====
@@ -6,6 +6,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): erro
       constructor() {
          yield foo
          ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression13_es6.errors.txt b/tests/baselines/reference/YieldExpression13_es6.errors.txt
index fc2d885d3812e..57329bb142d64 100644
--- a/tests/baselines/reference/YieldExpression13_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression13_es6.errors.txt
@@ -1,10 +1,7 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,19): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts (1 errors) ====
     function* foo() { yield }
             ~
-!!! error TS9001: Generators are not currently supported.
-                      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
\ No newline at end of file
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression14_es6.errors.txt b/tests/baselines/reference/YieldExpression14_es6.errors.txt
index baeaf3ba30ed3..2e32e7a23880b 100644
--- a/tests/baselines/reference/YieldExpression14_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression14_es6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts (1 errors) ====
@@ -6,6 +6,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): erro
       foo() {
          yield foo
          ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression15_es6.errors.txt b/tests/baselines/reference/YieldExpression15_es6.errors.txt
index 5e548799f5d5b..bb60f6a8f76e1 100644
--- a/tests/baselines/reference/YieldExpression15_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression15_es6.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts(2,6): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts(2,6): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts (1 errors) ====
     var v = () => {
          yield foo
          ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
       }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression16_es6.errors.txt b/tests/baselines/reference/YieldExpression16_es6.errors.txt
index c0d2e4c8fc8c3..8eb7a7be4cf4e 100644
--- a/tests/baselines/reference/YieldExpression16_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression16_es6.errors.txt
@@ -1,14 +1,14 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ====
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       function bar() {
         yield foo;
         ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression17_es6.errors.txt b/tests/baselines/reference/YieldExpression17_es6.errors.txt
index b39f47b07f946..bc2622125265e 100644
--- a/tests/baselines/reference/YieldExpression17_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression17_es6.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts (3 errors) ====
@@ -10,4 +10,4 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): err
                   ~~~
 !!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
                           ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
\ No newline at end of file
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression18_es6.errors.txt b/tests/baselines/reference/YieldExpression18_es6.errors.txt
index 3a67acdebcdff..056fc0e950a6d 100644
--- a/tests/baselines/reference/YieldExpression18_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression18_es6.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts(2,1): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts(2,1): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts (1 errors) ====
     "use strict";
     yield(foo);
     ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
\ No newline at end of file
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression19_es6.errors.txt b/tests/baselines/reference/YieldExpression19_es6.errors.txt
index 9d04d9559b02f..7d7db15ebb69f 100644
--- a/tests/baselines/reference/YieldExpression19_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression19_es6.errors.txt
@@ -1,19 +1,16 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(3,13): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(4,7): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(3,13): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts (3 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts (2 errors) ====
     function*foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       function bar() {
         function* quux() {
                 ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
           yield(foo);
-          ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
         }
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression2_es6.errors.txt b/tests/baselines/reference/YieldExpression2_es6.errors.txt
index 553dab51fc20f..2d1a7082d53b9 100644
--- a/tests/baselines/reference/YieldExpression2_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression2_es6.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts(1,1): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts(1,1): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts (1 errors) ====
     yield foo;
     ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
\ No newline at end of file
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression3_es6.errors.txt b/tests/baselines/reference/YieldExpression3_es6.errors.txt
index 1e284c9278633..01bd5a54d596f 100644
--- a/tests/baselines/reference/YieldExpression3_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression3_es6.errors.txt
@@ -1,16 +1,10 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(2,3): error TS9000: 'yield' expressions are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(3,3): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts (3 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       yield
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
       yield
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression4_es6.errors.txt b/tests/baselines/reference/YieldExpression4_es6.errors.txt
index 2d2a7ca325739..dbb543ba86e4c 100644
--- a/tests/baselines/reference/YieldExpression4_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression4_es6.errors.txt
@@ -1,16 +1,10 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(2,3): error TS9000: 'yield' expressions are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(3,3): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts (3 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       yield;
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
       yield;
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression6_es6.errors.txt b/tests/baselines/reference/YieldExpression6_es6.errors.txt
index a3d9481601acf..a90cc45d24fda 100644
--- a/tests/baselines/reference/YieldExpression6_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression6_es6.errors.txt
@@ -1,12 +1,12 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(2,3): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(2,9): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (2 errors) ====
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       yield*foo
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
+            ~~~
+!!! 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/YieldExpression7_es6.errors.txt b/tests/baselines/reference/YieldExpression7_es6.errors.txt
index 393a03ee2697d..067d11ecde62c 100644
--- a/tests/baselines/reference/YieldExpression7_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression7_es6.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(2,3): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       yield foo
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression8_es6.errors.txt b/tests/baselines/reference/YieldExpression8_es6.errors.txt
index 3f7933c5bb2d9..32ee997e38a9d 100644
--- a/tests/baselines/reference/YieldExpression8_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression8_es6.errors.txt
@@ -1,16 +1,13 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(1,1): error TS2304: Cannot find name 'yield'.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(3,3): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (3 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (2 errors) ====
     yield(foo);
     ~~~~~
 !!! error TS2304: Cannot find name 'yield'.
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       yield(foo);
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression9_es6.errors.txt b/tests/baselines/reference/YieldExpression9_es6.errors.txt
index cd753647327b5..2bd42847e646e 100644
--- a/tests/baselines/reference/YieldExpression9_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression9_es6.errors.txt
@@ -1,12 +1,12 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(1,17): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(2,3): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(1,17): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(2,9): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (2 errors) ====
     var v = function*() {
                     ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
       yield(foo);
-      ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
+            ~~~
+!!! error TS2304: Cannot find name 'foo'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldStarExpression1_es6.errors.txt b/tests/baselines/reference/YieldStarExpression1_es6.errors.txt
new file mode 100644
index 0000000000000..9ba5e44f9aa1a
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression1_es6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts(1,1): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts(1,9): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts (2 errors) ====
+    yield * [];
+    ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+            ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldStarExpression1_es6.js b/tests/baselines/reference/YieldStarExpression1_es6.js
new file mode 100644
index 0000000000000..742c5b7d1e7d6
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression1_es6.js
@@ -0,0 +1,5 @@
+//// [YieldStarExpression1_es6.ts]
+yield * [];
+
+//// [YieldStarExpression1_es6.js]
+yield * [];
diff --git a/tests/baselines/reference/YieldStarExpression2_es6.errors.txt b/tests/baselines/reference/YieldStarExpression2_es6.errors.txt
new file mode 100644
index 0000000000000..3d0c89fd23f0c
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression2_es6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts(1,1): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts(1,8): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts (2 errors) ====
+    yield *;
+    ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+           ~
+!!! error TS1109: Expression expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldStarExpression2_es6.js b/tests/baselines/reference/YieldStarExpression2_es6.js
new file mode 100644
index 0000000000000..5b40963d9a2bf
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression2_es6.js
@@ -0,0 +1,5 @@
+//// [YieldStarExpression2_es6.ts]
+yield *;
+
+//// [YieldStarExpression2_es6.js]
+yield * ;
diff --git a/tests/baselines/reference/YieldStarExpression3_es6.errors.txt b/tests/baselines/reference/YieldStarExpression3_es6.errors.txt
new file mode 100644
index 0000000000000..25cecc804449d
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression3_es6.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts(2,12): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts (1 errors) ====
+    function *g() {
+        yield *;
+               ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldStarExpression3_es6.js b/tests/baselines/reference/YieldStarExpression3_es6.js
new file mode 100644
index 0000000000000..7463fc01bc113
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression3_es6.js
@@ -0,0 +1,9 @@
+//// [YieldStarExpression3_es6.ts]
+function *g() {
+    yield *;
+}
+
+//// [YieldStarExpression3_es6.js]
+function g() {
+    yield* ;
+}
diff --git a/tests/baselines/reference/YieldStarExpression4_es6.errors.txt b/tests/baselines/reference/YieldStarExpression4_es6.errors.txt
new file mode 100644
index 0000000000000..6247a366ba880
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression4_es6.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(1,10): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(2,13): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts (2 errors) ====
+    function *g() {
+             ~
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
+        yield * [];
+                ~~
+!!! 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/YieldStarExpression4_es6.js b/tests/baselines/reference/YieldStarExpression4_es6.js
new file mode 100644
index 0000000000000..6283b81cca30b
--- /dev/null
+++ b/tests/baselines/reference/YieldStarExpression4_es6.js
@@ -0,0 +1,9 @@
+//// [YieldStarExpression4_es6.ts]
+function *g() {
+    yield * [];
+}
+
+//// [YieldStarExpression4_es6.js]
+function g() {
+    yield* [];
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index ce86a2bd59a85..48564baf79600 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -5,7 +5,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1691, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         let arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index f396414521edb..5f62de9bfa1ff 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1691, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         const arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index b484e2d72e171..b54ac35ba783a 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1691, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index 10c43123fa365..df900ac860e98 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1691, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index 4598ec0a30593..4d0887c1ff876 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1691, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;
diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols
index 019f44118cea5..739d9be0af070 100644
--- a/tests/baselines/reference/for-of37.symbols
+++ b/tests/baselines/reference/for-of37.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of37.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of37.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11))
 
 for (var v of map) {
 >v : Symbol(v, Decl(for-of37.ts, 1, 8))
diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols
index db15a4dcb87d3..9322fea69e675 100644
--- a/tests/baselines/reference/for-of38.symbols
+++ b/tests/baselines/reference/for-of38.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of38.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of38.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11))
 
 for (var [k, v] of map) {
 >k : Symbol(k, Decl(for-of38.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols
index 625ee544225de..72bbf78884e07 100644
--- a/tests/baselines/reference/for-of40.symbols
+++ b/tests/baselines/reference/for-of40.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of40.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of40.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11))
 
 for (var [k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of40.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols
index 343c5a38c971e..e1e7717269f8d 100644
--- a/tests/baselines/reference/for-of45.symbols
+++ b/tests/baselines/reference/for-of45.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of45.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols
index f16364548ce1d..571dd9dc3896e 100644
--- a/tests/baselines/reference/for-of50.symbols
+++ b/tests/baselines/reference/for-of50.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of50.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of50.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11))
 
 for (const [k, v] of map) {
 >k : Symbol(k, Decl(for-of50.ts, 1, 12))
diff --git a/tests/baselines/reference/generatorES6_1.errors.txt b/tests/baselines/reference/generatorES6_1.errors.txt
deleted file mode 100644
index b02da7f0b5349..0000000000000
--- a/tests/baselines/reference/generatorES6_1.errors.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-tests/cases/compiler/generatorES6_1.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/compiler/generatorES6_1.ts(2,5): error TS9000: 'yield' expressions are not currently supported.
-
-
-==== tests/cases/compiler/generatorES6_1.ts (2 errors) ====
-    function* foo() {
-            ~
-!!! error TS9001: Generators are not currently supported.
-        yield
-        ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorES6_1.symbols b/tests/baselines/reference/generatorES6_1.symbols
new file mode 100644
index 0000000000000..fc5aa602e0187
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_1.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/generatorES6_1.ts ===
+function* foo() {
+>foo : Symbol(foo, Decl(generatorES6_1.ts, 0, 0))
+
+    yield
+}
diff --git a/tests/baselines/reference/generatorES6_1.types b/tests/baselines/reference/generatorES6_1.types
new file mode 100644
index 0000000000000..13ac7c05844a6
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_1.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/generatorES6_1.ts ===
+function* foo() {
+>foo : () => IterableIterator<any>
+
+    yield
+>yield : any
+}
diff --git a/tests/baselines/reference/generatorES6_2.errors.txt b/tests/baselines/reference/generatorES6_2.errors.txt
deleted file mode 100644
index 8d956fc7f6361..0000000000000
--- a/tests/baselines/reference/generatorES6_2.errors.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-tests/cases/compiler/generatorES6_2.ts(2,12): error TS9001: Generators are not currently supported.
-tests/cases/compiler/generatorES6_2.ts(3,9): error TS9000: 'yield' expressions are not currently supported.
-
-
-==== tests/cases/compiler/generatorES6_2.ts (2 errors) ====
-    class C {
-        public * foo() {
-               ~
-!!! error TS9001: Generators are not currently supported.
-            yield 1
-            ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
-        }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorES6_2.symbols b/tests/baselines/reference/generatorES6_2.symbols
new file mode 100644
index 0000000000000..a64b1304692ce
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_2.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/generatorES6_2.ts ===
+class C {
+>C : Symbol(C, Decl(generatorES6_2.ts, 0, 0))
+
+    public * foo() {
+>foo : Symbol(foo, Decl(generatorES6_2.ts, 0, 9))
+
+        yield 1
+    }
+}
diff --git a/tests/baselines/reference/generatorES6_2.types b/tests/baselines/reference/generatorES6_2.types
new file mode 100644
index 0000000000000..9c9c8692757bb
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_2.types
@@ -0,0 +1,12 @@
+=== tests/cases/compiler/generatorES6_2.ts ===
+class C {
+>C : C
+
+    public * foo() {
+>foo : () => IterableIterator<number>
+
+        yield 1
+>yield 1 : any
+>1 : number
+    }
+}
diff --git a/tests/baselines/reference/generatorES6_3.errors.txt b/tests/baselines/reference/generatorES6_3.errors.txt
deleted file mode 100644
index e1c1d918ce658..0000000000000
--- a/tests/baselines/reference/generatorES6_3.errors.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-tests/cases/compiler/generatorES6_3.ts(1,17): error TS9001: Generators are not currently supported.
-tests/cases/compiler/generatorES6_3.ts(2,5): error TS9000: 'yield' expressions are not currently supported.
-
-
-==== tests/cases/compiler/generatorES6_3.ts (2 errors) ====
-    var v = function*() {
-                    ~
-!!! error TS9001: Generators are not currently supported.
-        yield 0
-        ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorES6_3.symbols b/tests/baselines/reference/generatorES6_3.symbols
new file mode 100644
index 0000000000000..329c96e6de8ec
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_3.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/generatorES6_3.ts ===
+var v = function*() {
+>v : Symbol(v, Decl(generatorES6_3.ts, 0, 3))
+
+    yield 0
+}
diff --git a/tests/baselines/reference/generatorES6_3.types b/tests/baselines/reference/generatorES6_3.types
new file mode 100644
index 0000000000000..e87ad23ba77bc
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_3.types
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/generatorES6_3.ts ===
+var v = function*() {
+>v : () => IterableIterator<number>
+>function*() {    yield 0} : () => IterableIterator<number>
+
+    yield 0
+>yield 0 : any
+>0 : number
+}
diff --git a/tests/baselines/reference/generatorES6_4.errors.txt b/tests/baselines/reference/generatorES6_4.errors.txt
deleted file mode 100644
index 37c375e9728ab..0000000000000
--- a/tests/baselines/reference/generatorES6_4.errors.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-tests/cases/compiler/generatorES6_4.ts(2,4): error TS9001: Generators are not currently supported.
-tests/cases/compiler/generatorES6_4.ts(3,8): error TS9000: 'yield' expressions are not currently supported.
-
-
-==== tests/cases/compiler/generatorES6_4.ts (2 errors) ====
-    var v = { 
-       *foo() {
-       ~
-!!! error TS9001: Generators are not currently supported.
-           yield 0
-           ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
-       }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorES6_4.symbols b/tests/baselines/reference/generatorES6_4.symbols
new file mode 100644
index 0000000000000..fc514dad45f1e
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_4.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/generatorES6_4.ts ===
+var v = { 
+>v : Symbol(v, Decl(generatorES6_4.ts, 0, 3))
+
+   *foo() {
+>foo : Symbol(foo, Decl(generatorES6_4.ts, 0, 9))
+
+       yield 0
+   }
+}
diff --git a/tests/baselines/reference/generatorES6_4.types b/tests/baselines/reference/generatorES6_4.types
new file mode 100644
index 0000000000000..64b0924919b00
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_4.types
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/generatorES6_4.ts ===
+var v = { 
+>v : { foo(): IterableIterator<number>; }
+>{    *foo() {       yield 0   }} : { foo(): IterableIterator<number>; }
+
+   *foo() {
+>foo : () => IterableIterator<number>
+
+       yield 0
+>yield 0 : any
+>0 : number
+   }
+}
diff --git a/tests/baselines/reference/generatorES6_5.errors.txt b/tests/baselines/reference/generatorES6_5.errors.txt
index f6fa8a5bc18cd..20e6f3abe9f95 100644
--- a/tests/baselines/reference/generatorES6_5.errors.txt
+++ b/tests/baselines/reference/generatorES6_5.errors.txt
@@ -1,12 +1,15 @@
-tests/cases/compiler/generatorES6_5.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/compiler/generatorES6_5.ts(2,5): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/compiler/generatorES6_5.ts(2,11): error TS2304: Cannot find name 'a'.
+tests/cases/compiler/generatorES6_5.ts(2,15): error TS2304: Cannot find name 'b'.
+tests/cases/compiler/generatorES6_5.ts(2,19): error TS2304: Cannot find name 'c'.
 
 
-==== tests/cases/compiler/generatorES6_5.ts (2 errors) ====
+==== tests/cases/compiler/generatorES6_5.ts (3 errors) ====
     function* foo() {
-            ~
-!!! error TS9001: Generators are not currently supported.
         yield a ? b : c;
-        ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
+              ~
+!!! error TS2304: Cannot find name 'a'.
+                  ~
+!!! error TS2304: Cannot find name 'b'.
+                      ~
+!!! error TS2304: Cannot find name 'c'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorES6_6.errors.txt b/tests/baselines/reference/generatorES6_6.errors.txt
deleted file mode 100644
index 1f568aeb9e457..0000000000000
--- a/tests/baselines/reference/generatorES6_6.errors.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-tests/cases/compiler/generatorES6_6.ts(2,3): error TS9001: Generators are not currently supported.
-tests/cases/compiler/generatorES6_6.ts(3,13): error TS9000: 'yield' expressions are not currently supported.
-
-
-==== tests/cases/compiler/generatorES6_6.ts (2 errors) ====
-    class C {
-      *[Symbol.iterator]() {
-      ~
-!!! error TS9001: Generators are not currently supported.
-        let a = yield 1;
-                ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
-      }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorES6_6.symbols b/tests/baselines/reference/generatorES6_6.symbols
new file mode 100644
index 0000000000000..4cdac0f12c5bb
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_6.symbols
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/generatorES6_6.ts ===
+class C {
+>C : Symbol(C, Decl(generatorES6_6.ts, 0, 0))
+
+  *[Symbol.iterator]() {
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+
+    let a = yield 1;
+>a : Symbol(a, Decl(generatorES6_6.ts, 2, 7))
+  }
+}
diff --git a/tests/baselines/reference/generatorES6_6.types b/tests/baselines/reference/generatorES6_6.types
new file mode 100644
index 0000000000000..4e3de8cea1e9c
--- /dev/null
+++ b/tests/baselines/reference/generatorES6_6.types
@@ -0,0 +1,15 @@
+=== tests/cases/compiler/generatorES6_6.ts ===
+class C {
+>C : C
+
+  *[Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+    let a = yield 1;
+>a : any
+>yield 1 : any
+>1 : number
+  }
+}
diff --git a/tests/baselines/reference/generatorInAmbientContext1.errors.txt b/tests/baselines/reference/generatorInAmbientContext1.errors.txt
new file mode 100644
index 0000000000000..fcfcceb9ff51d
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext1.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext1.ts(2,5): error TS1220: Generators are not allowed in an ambient context.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext1.ts (1 errors) ====
+    declare class C {
+        *generator(): any;
+        ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorInAmbientContext1.js b/tests/baselines/reference/generatorInAmbientContext1.js
new file mode 100644
index 0000000000000..e7b4e03e64ea4
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext1.js
@@ -0,0 +1,6 @@
+//// [generatorInAmbientContext1.ts]
+declare class C {
+    *generator(): any;
+}
+
+//// [generatorInAmbientContext1.js]
diff --git a/tests/baselines/reference/generatorInAmbientContext2.errors.txt b/tests/baselines/reference/generatorInAmbientContext2.errors.txt
new file mode 100644
index 0000000000000..8f471ef98bc85
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext2.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext2.ts(2,14): error TS1220: Generators are not allowed in an ambient context.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext2.ts (1 errors) ====
+    declare module M {
+        function *generator(): any;
+                 ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorInAmbientContext2.js b/tests/baselines/reference/generatorInAmbientContext2.js
new file mode 100644
index 0000000000000..f7742ccc235c6
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext2.js
@@ -0,0 +1,6 @@
+//// [generatorInAmbientContext2.ts]
+declare module M {
+    function *generator(): any;
+}
+
+//// [generatorInAmbientContext2.js]
diff --git a/tests/baselines/reference/generatorInAmbientContext3.d.errors.txt b/tests/baselines/reference/generatorInAmbientContext3.d.errors.txt
new file mode 100644
index 0000000000000..44391cab73055
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext3.d.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext3.d.ts(2,5): error TS1220: Generators are not allowed in an ambient context.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext3.d.ts (1 errors) ====
+    declare class C {
+        *generator(): any;
+        ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorInAmbientContext4.d.errors.txt b/tests/baselines/reference/generatorInAmbientContext4.d.errors.txt
new file mode 100644
index 0000000000000..2b1701156f08d
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext4.d.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext4.d.ts(2,14): error TS1220: Generators are not allowed in an ambient context.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext4.d.ts (1 errors) ====
+    declare module M {
+        function *generator(): any;
+                 ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorInAmbientContext5.js b/tests/baselines/reference/generatorInAmbientContext5.js
new file mode 100644
index 0000000000000..044155e8dd5b5
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext5.js
@@ -0,0 +1,15 @@
+//// [generatorInAmbientContext5.ts]
+class C {
+    *generator(): any { }
+}
+
+//// [generatorInAmbientContext5.js]
+class C {
+    *generator() { }
+}
+
+
+//// [generatorInAmbientContext5.d.ts]
+declare class C {
+    generator(): any;
+}
diff --git a/tests/baselines/reference/generatorInAmbientContext5.symbols b/tests/baselines/reference/generatorInAmbientContext5.symbols
new file mode 100644
index 0000000000000..78139a7e59746
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext5.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext5.ts ===
+class C {
+>C : Symbol(C, Decl(generatorInAmbientContext5.ts, 0, 0))
+
+    *generator(): any { }
+>generator : Symbol(generator, Decl(generatorInAmbientContext5.ts, 0, 9))
+}
diff --git a/tests/baselines/reference/generatorInAmbientContext5.types b/tests/baselines/reference/generatorInAmbientContext5.types
new file mode 100644
index 0000000000000..169aba8201bb9
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext5.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext5.ts ===
+class C {
+>C : C
+
+    *generator(): any { }
+>generator : () => any
+}
diff --git a/tests/baselines/reference/generatorInAmbientContext6.js b/tests/baselines/reference/generatorInAmbientContext6.js
new file mode 100644
index 0000000000000..10cfa85d933af
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext6.js
@@ -0,0 +1,17 @@
+//// [generatorInAmbientContext6.ts]
+module M {
+    export function *generator(): any { }
+}
+
+//// [generatorInAmbientContext6.js]
+var M;
+(function (M) {
+    function* generator() { }
+    M.generator = generator;
+})(M || (M = {}));
+
+
+//// [generatorInAmbientContext6.d.ts]
+declare module M {
+    function generator(): any;
+}
diff --git a/tests/baselines/reference/generatorInAmbientContext6.symbols b/tests/baselines/reference/generatorInAmbientContext6.symbols
new file mode 100644
index 0000000000000..e921a2b1f9643
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext6.ts ===
+module M {
+>M : Symbol(M, Decl(generatorInAmbientContext6.ts, 0, 0))
+
+    export function *generator(): any { }
+>generator : Symbol(generator, Decl(generatorInAmbientContext6.ts, 0, 10))
+}
diff --git a/tests/baselines/reference/generatorInAmbientContext6.types b/tests/baselines/reference/generatorInAmbientContext6.types
new file mode 100644
index 0000000000000..d960126210e6c
--- /dev/null
+++ b/tests/baselines/reference/generatorInAmbientContext6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext6.ts ===
+module M {
+>M : typeof M
+
+    export function *generator(): any { }
+>generator : () => any
+}
diff --git a/tests/baselines/reference/generatorOverloads1.errors.txt b/tests/baselines/reference/generatorOverloads1.errors.txt
new file mode 100644
index 0000000000000..9d2b5a2ee41f1
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads1.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads1.ts(2,13): error TS1221: An overload signature cannot be declared as a generator.
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads1.ts(3,13): error TS1221: An overload signature cannot be declared as a generator.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorOverloads1.ts (2 errors) ====
+    module M {
+        function* f(s: string): Iterable<any>;
+                ~
+!!! error TS1221: An overload signature cannot be declared as a generator.
+        function* f(s: number): Iterable<any>;
+                ~
+!!! error TS1221: An overload signature cannot be declared as a generator.
+        function* f(s: any): Iterable<any> { }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorOverloads1.js b/tests/baselines/reference/generatorOverloads1.js
new file mode 100644
index 0000000000000..0ce5ae10f4d8b
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads1.js
@@ -0,0 +1,12 @@
+//// [generatorOverloads1.ts]
+module M {
+    function* f(s: string): Iterable<any>;
+    function* f(s: number): Iterable<any>;
+    function* f(s: any): Iterable<any> { }
+}
+
+//// [generatorOverloads1.js]
+var M;
+(function (M) {
+    function* f(s) { }
+})(M || (M = {}));
diff --git a/tests/baselines/reference/generatorOverloads2.errors.txt b/tests/baselines/reference/generatorOverloads2.errors.txt
new file mode 100644
index 0000000000000..53dad48de6369
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads2.errors.txt
@@ -0,0 +1,17 @@
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts(2,13): error TS1220: Generators are not allowed in an ambient context.
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts(3,13): error TS1220: Generators are not allowed in an ambient context.
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts(4,13): error TS1220: Generators are not allowed in an ambient context.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts (3 errors) ====
+    declare module M {
+        function* f(s: string): Iterable<any>;
+                ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+        function* f(s: number): Iterable<any>;
+                ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+        function* f(s: any): Iterable<any>;
+                ~
+!!! error TS1220: Generators are not allowed in an ambient context.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorOverloads2.js b/tests/baselines/reference/generatorOverloads2.js
new file mode 100644
index 0000000000000..4fa3837ed3675
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads2.js
@@ -0,0 +1,8 @@
+//// [generatorOverloads2.ts]
+declare module M {
+    function* f(s: string): Iterable<any>;
+    function* f(s: number): Iterable<any>;
+    function* f(s: any): Iterable<any>;
+}
+
+//// [generatorOverloads2.js]
diff --git a/tests/baselines/reference/generatorOverloads3.errors.txt b/tests/baselines/reference/generatorOverloads3.errors.txt
new file mode 100644
index 0000000000000..c68e2fac0b0a1
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads3.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads3.ts(2,5): error TS1221: An overload signature cannot be declared as a generator.
+tests/cases/conformance/es6/yieldExpressions/generatorOverloads3.ts(3,5): error TS1221: An overload signature cannot be declared as a generator.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorOverloads3.ts (2 errors) ====
+    class C {
+        *f(s: string): Iterable<any>;
+        ~
+!!! error TS1221: An overload signature cannot be declared as a generator.
+        *f(s: number): Iterable<any>;
+        ~
+!!! error TS1221: An overload signature cannot be declared as a generator.
+        *f(s: any): Iterable<any> { }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorOverloads3.js b/tests/baselines/reference/generatorOverloads3.js
new file mode 100644
index 0000000000000..55ba5dcdc99e2
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads3.js
@@ -0,0 +1,11 @@
+//// [generatorOverloads3.ts]
+class C {
+    *f(s: string): Iterable<any>;
+    *f(s: number): Iterable<any>;
+    *f(s: any): Iterable<any> { }
+}
+
+//// [generatorOverloads3.js]
+class C {
+    *f(s) { }
+}
diff --git a/tests/baselines/reference/generatorOverloads4.js b/tests/baselines/reference/generatorOverloads4.js
new file mode 100644
index 0000000000000..8ebbcb593814a
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads4.js
@@ -0,0 +1,11 @@
+//// [generatorOverloads4.ts]
+class C {
+    f(s: string): Iterable<any>;
+    f(s: number): Iterable<any>;
+    *f(s: any): Iterable<any> { }
+}
+
+//// [generatorOverloads4.js]
+class C {
+    *f(s) { }
+}
diff --git a/tests/baselines/reference/generatorOverloads4.symbols b/tests/baselines/reference/generatorOverloads4.symbols
new file mode 100644
index 0000000000000..afae1c1a808cc
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads4.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorOverloads4.ts ===
+class C {
+>C : Symbol(C, Decl(generatorOverloads4.ts, 0, 0))
+
+    f(s: string): Iterable<any>;
+>f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
+>s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+
+    f(s: number): Iterable<any>;
+>f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
+>s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+
+    *f(s: any): Iterable<any> { }
+>f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
+>s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+}
diff --git a/tests/baselines/reference/generatorOverloads4.types b/tests/baselines/reference/generatorOverloads4.types
new file mode 100644
index 0000000000000..493e0ac307c24
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads4.types
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorOverloads4.ts ===
+class C {
+>C : C
+
+    f(s: string): Iterable<any>;
+>f : { (s: string): Iterable<any>; (s: number): Iterable<any>; }
+>s : string
+>Iterable : Iterable<T>
+
+    f(s: number): Iterable<any>;
+>f : { (s: string): Iterable<any>; (s: number): Iterable<any>; }
+>s : number
+>Iterable : Iterable<T>
+
+    *f(s: any): Iterable<any> { }
+>f : { (s: string): Iterable<any>; (s: number): Iterable<any>; }
+>s : any
+>Iterable : Iterable<T>
+}
diff --git a/tests/baselines/reference/generatorOverloads5.js b/tests/baselines/reference/generatorOverloads5.js
new file mode 100644
index 0000000000000..c6d928045fab1
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads5.js
@@ -0,0 +1,12 @@
+//// [generatorOverloads5.ts]
+module M {
+    function f(s: string): Iterable<any>;
+    function f(s: number): Iterable<any>;
+    function* f(s: any): Iterable<any> { }
+}
+
+//// [generatorOverloads5.js]
+var M;
+(function (M) {
+    function* f(s) { }
+})(M || (M = {}));
diff --git a/tests/baselines/reference/generatorOverloads5.symbols b/tests/baselines/reference/generatorOverloads5.symbols
new file mode 100644
index 0000000000000..0a14548d197d1
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads5.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorOverloads5.ts ===
+module M {
+>M : Symbol(M, Decl(generatorOverloads5.ts, 0, 0))
+
+    function f(s: string): Iterable<any>;
+>f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
+>s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+
+    function f(s: number): Iterable<any>;
+>f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
+>s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+
+    function* f(s: any): Iterable<any> { }
+>f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
+>s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+}
diff --git a/tests/baselines/reference/generatorOverloads5.types b/tests/baselines/reference/generatorOverloads5.types
new file mode 100644
index 0000000000000..276baf1ff4043
--- /dev/null
+++ b/tests/baselines/reference/generatorOverloads5.types
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorOverloads5.ts ===
+module M {
+>M : typeof M
+
+    function f(s: string): Iterable<any>;
+>f : { (s: string): Iterable<any>; (s: number): Iterable<any>; }
+>s : string
+>Iterable : Iterable<T>
+
+    function f(s: number): Iterable<any>;
+>f : { (s: string): Iterable<any>; (s: number): Iterable<any>; }
+>s : number
+>Iterable : Iterable<T>
+
+    function* f(s: any): Iterable<any> { }
+>f : { (s: string): Iterable<any>; (s: number): Iterable<any>; }
+>s : any
+>Iterable : Iterable<T>
+}
diff --git a/tests/baselines/reference/generatorTypeCheck1.js b/tests/baselines/reference/generatorTypeCheck1.js
new file mode 100644
index 0000000000000..eb3cbcd2fe0f2
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck1.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck1.ts]
+function* g1(): Iterator<string> { }
+
+//// [generatorTypeCheck1.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols
new file mode 100644
index 0000000000000..58ee2aa66f83f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck1.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
+function* g1(): Iterator<string> { }
+>g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1662, 1))
+
diff --git a/tests/baselines/reference/generatorTypeCheck1.types b/tests/baselines/reference/generatorTypeCheck1.types
new file mode 100644
index 0000000000000..3f02fe4b09545
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck1.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
+function* g1(): Iterator<string> { }
+>g1 : () => Iterator<string>
+>Iterator : Iterator<T>
+
diff --git a/tests/baselines/reference/generatorTypeCheck10.js b/tests/baselines/reference/generatorTypeCheck10.js
new file mode 100644
index 0000000000000..252f3011613bc
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck10.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck10.ts]
+function* g(): IterableIterator<any> {
+    return;
+}
+
+//// [generatorTypeCheck10.js]
+function* g() {
+    return;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck10.symbols b/tests/baselines/reference/generatorTypeCheck10.symbols
new file mode 100644
index 0000000000000..c6eeb6b4a3d17
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck10.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts ===
+function* g(): IterableIterator<any> {
+>g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+
+    return;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck10.types b/tests/baselines/reference/generatorTypeCheck10.types
new file mode 100644
index 0000000000000..f9304e3b16854
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck10.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts ===
+function* g(): IterableIterator<any> {
+>g : () => IterableIterator<any>
+>IterableIterator : IterableIterator<T>
+
+    return;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck11.js b/tests/baselines/reference/generatorTypeCheck11.js
new file mode 100644
index 0000000000000..4898f661f265a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck11.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck11.ts]
+function* g(): IterableIterator<number> {
+    return 0;
+}
+
+//// [generatorTypeCheck11.js]
+function* g() {
+    return 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols
new file mode 100644
index 0000000000000..b904dfb446b30
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck11.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts ===
+function* g(): IterableIterator<number> {
+>g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+
+    return 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck11.types b/tests/baselines/reference/generatorTypeCheck11.types
new file mode 100644
index 0000000000000..ce47d49785174
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck11.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts ===
+function* g(): IterableIterator<number> {
+>g : () => IterableIterator<number>
+>IterableIterator : IterableIterator<T>
+
+    return 0;
+>0 : number
+}
diff --git a/tests/baselines/reference/generatorTypeCheck12.js b/tests/baselines/reference/generatorTypeCheck12.js
new file mode 100644
index 0000000000000..058b0a0772df0
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck12.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck12.ts]
+function* g(): IterableIterator<number> {
+    return "";
+}
+
+//// [generatorTypeCheck12.js]
+function* g() {
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols
new file mode 100644
index 0000000000000..e596203b9eb2c
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck12.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts ===
+function* g(): IterableIterator<number> {
+>g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck12.types b/tests/baselines/reference/generatorTypeCheck12.types
new file mode 100644
index 0000000000000..3dd3c20f18d66
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck12.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts ===
+function* g(): IterableIterator<number> {
+>g : () => IterableIterator<number>
+>IterableIterator : IterableIterator<T>
+
+    return "";
+>"" : string
+}
diff --git a/tests/baselines/reference/generatorTypeCheck13.js b/tests/baselines/reference/generatorTypeCheck13.js
new file mode 100644
index 0000000000000..26308b0ac7e96
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck13.js
@@ -0,0 +1,11 @@
+//// [generatorTypeCheck13.ts]
+function* g(): IterableIterator<number> {
+    yield 0;
+    return "";
+}
+
+//// [generatorTypeCheck13.js]
+function* g() {
+    yield 0;
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols
new file mode 100644
index 0000000000000..84e42a06cfd31
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck13.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts ===
+function* g(): IterableIterator<number> {
+>g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+
+    yield 0;
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck13.types b/tests/baselines/reference/generatorTypeCheck13.types
new file mode 100644
index 0000000000000..d77b630ae720f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck13.types
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts ===
+function* g(): IterableIterator<number> {
+>g : () => IterableIterator<number>
+>IterableIterator : IterableIterator<T>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+
+    return "";
+>"" : string
+}
diff --git a/tests/baselines/reference/generatorTypeCheck14.js b/tests/baselines/reference/generatorTypeCheck14.js
new file mode 100644
index 0000000000000..a7dcc87a3a989
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck14.js
@@ -0,0 +1,11 @@
+//// [generatorTypeCheck14.ts]
+function* g() {
+    yield 0;
+    return "";
+}
+
+//// [generatorTypeCheck14.js]
+function* g() {
+    yield 0;
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck14.symbols b/tests/baselines/reference/generatorTypeCheck14.symbols
new file mode 100644
index 0000000000000..36d10d885456a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck14.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck14.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck14.ts, 0, 0))
+
+    yield 0;
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck14.types b/tests/baselines/reference/generatorTypeCheck14.types
new file mode 100644
index 0000000000000..db1b5bde19a1a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck14.types
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck14.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+
+    return "";
+>"" : string
+}
diff --git a/tests/baselines/reference/generatorTypeCheck15.js b/tests/baselines/reference/generatorTypeCheck15.js
new file mode 100644
index 0000000000000..d359c10048652
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck15.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck15.ts]
+function* g() {
+    return "";
+}
+
+//// [generatorTypeCheck15.js]
+function* g() {
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck15.symbols b/tests/baselines/reference/generatorTypeCheck15.symbols
new file mode 100644
index 0000000000000..3d914d0bd6faa
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck15.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck15.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck15.ts, 0, 0))
+
+    return "";
+}
diff --git a/tests/baselines/reference/generatorTypeCheck15.types b/tests/baselines/reference/generatorTypeCheck15.types
new file mode 100644
index 0000000000000..4437d78572d9f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck15.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck15.ts ===
+function* g() {
+>g : () => IterableIterator<any>
+
+    return "";
+>"" : string
+}
diff --git a/tests/baselines/reference/generatorTypeCheck16.js b/tests/baselines/reference/generatorTypeCheck16.js
new file mode 100644
index 0000000000000..7b8b93deabdac
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck16.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck16.ts]
+function* g() {
+    return;
+}
+
+//// [generatorTypeCheck16.js]
+function* g() {
+    return;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck16.symbols b/tests/baselines/reference/generatorTypeCheck16.symbols
new file mode 100644
index 0000000000000..bbc22cc4a2de5
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck16.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck16.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck16.ts, 0, 0))
+
+    return;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck16.types b/tests/baselines/reference/generatorTypeCheck16.types
new file mode 100644
index 0000000000000..a607ad851c198
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck16.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck16.ts ===
+function* g() {
+>g : () => IterableIterator<any>
+
+    return;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck17.js b/tests/baselines/reference/generatorTypeCheck17.js
new file mode 100644
index 0000000000000..8c3ebb59ea663
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck17.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck17.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield new Bar;
+}
+
+//// [generatorTypeCheck17.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+function* g() {
+    yield;
+    yield new Bar;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck17.symbols b/tests/baselines/reference/generatorTypeCheck17.symbols
new file mode 100644
index 0000000000000..9e689d9df42fb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck17.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck17.ts ===
+class Foo { x: number }
+>Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
+>x : Symbol(x, Decl(generatorTypeCheck17.ts, 0, 11))
+
+class Bar extends Foo { y: string }
+>Bar : Symbol(Bar, Decl(generatorTypeCheck17.ts, 0, 23))
+>Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
+>y : Symbol(y, Decl(generatorTypeCheck17.ts, 1, 23))
+
+function* g(): IterableIterator<Foo> {
+>g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+>Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
+
+    yield;
+    yield new Bar;
+>Bar : Symbol(Bar, Decl(generatorTypeCheck17.ts, 0, 23))
+}
diff --git a/tests/baselines/reference/generatorTypeCheck17.types b/tests/baselines/reference/generatorTypeCheck17.types
new file mode 100644
index 0000000000000..0ea7212040b72
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck17.types
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck17.ts ===
+class Foo { x: number }
+>Foo : Foo
+>x : number
+
+class Bar extends Foo { y: string }
+>Bar : Bar
+>Foo : Foo
+>y : string
+
+function* g(): IterableIterator<Foo> {
+>g : () => IterableIterator<Foo>
+>IterableIterator : IterableIterator<T>
+>Foo : Foo
+
+    yield;
+>yield : any
+
+    yield new Bar;
+>yield new Bar : any
+>new Bar : Bar
+>Bar : typeof Bar
+}
diff --git a/tests/baselines/reference/generatorTypeCheck18.errors.txt b/tests/baselines/reference/generatorTypeCheck18.errors.txt
new file mode 100644
index 0000000000000..2c6deab9821eb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck18.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck18.ts(5,11): error TS2322: Type 'Baz' is not assignable to type 'Foo'.
+  Property 'x' is missing in type 'Baz'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck18.ts (1 errors) ====
+    class Foo { x: number }
+    class Baz { z: number }
+    function* g(): IterableIterator<Foo> {
+        yield;
+        yield new Baz;
+              ~~~~~~~
+!!! error TS2322: Type 'Baz' is not assignable to type 'Foo'.
+!!! error TS2322:   Property 'x' is missing in type 'Baz'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck18.js b/tests/baselines/reference/generatorTypeCheck18.js
new file mode 100644
index 0000000000000..5907dd14b2935
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck18.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck18.ts]
+class Foo { x: number }
+class Baz { z: number }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield new Baz;
+}
+
+//// [generatorTypeCheck18.js]
+class Foo {
+}
+class Baz {
+}
+function* g() {
+    yield;
+    yield new Baz;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck19.js b/tests/baselines/reference/generatorTypeCheck19.js
new file mode 100644
index 0000000000000..375d7b36ecc9f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck19.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck19.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield * [new Bar];
+}
+
+//// [generatorTypeCheck19.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+function* g() {
+    yield;
+    yield* [new Bar];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck19.symbols b/tests/baselines/reference/generatorTypeCheck19.symbols
new file mode 100644
index 0000000000000..2edec8fd21a8e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck19.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck19.ts ===
+class Foo { x: number }
+>Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
+>x : Symbol(x, Decl(generatorTypeCheck19.ts, 0, 11))
+
+class Bar extends Foo { y: string }
+>Bar : Symbol(Bar, Decl(generatorTypeCheck19.ts, 0, 23))
+>Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
+>y : Symbol(y, Decl(generatorTypeCheck19.ts, 1, 23))
+
+function* g(): IterableIterator<Foo> {
+>g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+>Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
+
+    yield;
+    yield * [new Bar];
+>Bar : Symbol(Bar, Decl(generatorTypeCheck19.ts, 0, 23))
+}
diff --git a/tests/baselines/reference/generatorTypeCheck19.types b/tests/baselines/reference/generatorTypeCheck19.types
new file mode 100644
index 0000000000000..2b4f1396c2eb8
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck19.types
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck19.ts ===
+class Foo { x: number }
+>Foo : Foo
+>x : number
+
+class Bar extends Foo { y: string }
+>Bar : Bar
+>Foo : Foo
+>y : string
+
+function* g(): IterableIterator<Foo> {
+>g : () => IterableIterator<Foo>
+>IterableIterator : IterableIterator<T>
+>Foo : Foo
+
+    yield;
+>yield : any
+
+    yield * [new Bar];
+>yield * [new Bar] : any
+>[new Bar] : Bar[]
+>new Bar : Bar
+>Bar : typeof Bar
+}
diff --git a/tests/baselines/reference/generatorTypeCheck2.js b/tests/baselines/reference/generatorTypeCheck2.js
new file mode 100644
index 0000000000000..559946b0fcbce
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck2.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck2.ts]
+function* g1(): Iterable<string> { }
+
+//// [generatorTypeCheck2.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck2.symbols b/tests/baselines/reference/generatorTypeCheck2.symbols
new file mode 100644
index 0000000000000..e066878659893
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck2.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts ===
+function* g1(): Iterable<string> { }
+>g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+
diff --git a/tests/baselines/reference/generatorTypeCheck2.types b/tests/baselines/reference/generatorTypeCheck2.types
new file mode 100644
index 0000000000000..882367fa3d499
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck2.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts ===
+function* g1(): Iterable<string> { }
+>g1 : () => Iterable<string>
+>Iterable : Iterable<T>
+
diff --git a/tests/baselines/reference/generatorTypeCheck20.errors.txt b/tests/baselines/reference/generatorTypeCheck20.errors.txt
new file mode 100644
index 0000000000000..c6e8200d106b6
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck20.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck20.ts(5,13): error TS2322: Type 'Baz' is not assignable to type 'Foo'.
+  Property 'x' is missing in type 'Baz'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck20.ts (1 errors) ====
+    class Foo { x: number }
+    class Baz { z: number }
+    function* g(): IterableIterator<Foo> {
+        yield;
+        yield * [new Baz];
+                ~~~~~~~~~
+!!! error TS2322: Type 'Baz' is not assignable to type 'Foo'.
+!!! error TS2322:   Property 'x' is missing in type 'Baz'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck20.js b/tests/baselines/reference/generatorTypeCheck20.js
new file mode 100644
index 0000000000000..c7336079bf0ea
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck20.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck20.ts]
+class Foo { x: number }
+class Baz { z: number }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield * [new Baz];
+}
+
+//// [generatorTypeCheck20.js]
+class Foo {
+}
+class Baz {
+}
+function* g() {
+    yield;
+    yield* [new Baz];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck21.errors.txt b/tests/baselines/reference/generatorTypeCheck21.errors.txt
new file mode 100644
index 0000000000000..0ef66aa1bd755
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck21.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck21.ts(5,13): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck21.ts (1 errors) ====
+    class Foo { x: number }
+    class Bar extends Foo { y: string }
+    function* g(): IterableIterator<Foo> {
+        yield;
+        yield * new Bar;
+                ~~~~~~~
+!!! 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/generatorTypeCheck21.js b/tests/baselines/reference/generatorTypeCheck21.js
new file mode 100644
index 0000000000000..83d1007a2c2a1
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck21.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck21.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield * new Bar;
+}
+
+//// [generatorTypeCheck21.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+function* g() {
+    yield;
+    yield* new Bar;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck22.errors.txt b/tests/baselines/reference/generatorTypeCheck22.errors.txt
new file mode 100644
index 0000000000000..ab2b3de4f42c7
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck22.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck22.ts(4,11): error TS2504: No best common type exists among yield expressions.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck22.ts (1 errors) ====
+    class Foo { x: number }
+    class Bar extends Foo { y: string }
+    class Baz { z: number }
+    function* g3() {
+              ~~
+!!! error TS2504: No best common type exists among yield expressions.
+        yield;
+        yield new Bar;
+        yield new Baz;
+        yield *[new Bar];
+        yield *[new Baz];
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck22.js b/tests/baselines/reference/generatorTypeCheck22.js
new file mode 100644
index 0000000000000..0045e115e6fb1
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck22.js
@@ -0,0 +1,26 @@
+//// [generatorTypeCheck22.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+function* g3() {
+    yield;
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
+
+//// [generatorTypeCheck22.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+class Baz {
+}
+function* g3() {
+    yield;
+    yield new Bar;
+    yield new Baz;
+    yield* [new Bar];
+    yield* [new Baz];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck23.errors.txt b/tests/baselines/reference/generatorTypeCheck23.errors.txt
new file mode 100644
index 0000000000000..9e85117a0a884
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck23.errors.txt
@@ -0,0 +1,17 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck23.ts(4,11): error TS2504: No best common type exists among yield expressions.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck23.ts (1 errors) ====
+    class Foo { x: number }
+    class Bar extends Foo { y: string }
+    class Baz { z: number }
+    function* g3() {
+              ~~
+!!! error TS2504: No best common type exists among yield expressions.
+        yield;
+        yield new Foo;
+        yield new Bar;
+        yield new Baz;
+        yield *[new Bar];
+        yield *[new Baz];
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck23.js b/tests/baselines/reference/generatorTypeCheck23.js
new file mode 100644
index 0000000000000..37c2c239e2c23
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck23.js
@@ -0,0 +1,28 @@
+//// [generatorTypeCheck23.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+function* g3() {
+    yield;
+    yield new Foo;
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
+
+//// [generatorTypeCheck23.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+class Baz {
+}
+function* g3() {
+    yield;
+    yield new Foo;
+    yield new Bar;
+    yield new Baz;
+    yield* [new Bar];
+    yield* [new Baz];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck24.errors.txt b/tests/baselines/reference/generatorTypeCheck24.errors.txt
new file mode 100644
index 0000000000000..b4ca13c14c24a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck24.errors.txt
@@ -0,0 +1,17 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck24.ts(4,11): error TS2504: No best common type exists among yield expressions.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck24.ts (1 errors) ====
+    class Foo { x: number }
+    class Bar extends Foo { y: string }
+    class Baz { z: number }
+    function* g3() {
+              ~~
+!!! error TS2504: No best common type exists among yield expressions.
+        yield;
+        yield * [new Foo];
+        yield new Bar;
+        yield new Baz;
+        yield *[new Bar];
+        yield *[new Baz];
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck24.js b/tests/baselines/reference/generatorTypeCheck24.js
new file mode 100644
index 0000000000000..8b6018243caaf
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck24.js
@@ -0,0 +1,28 @@
+//// [generatorTypeCheck24.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+function* g3() {
+    yield;
+    yield * [new Foo];
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
+
+//// [generatorTypeCheck24.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+class Baz {
+}
+function* g3() {
+    yield;
+    yield* [new Foo];
+    yield new Bar;
+    yield new Baz;
+    yield* [new Bar];
+    yield* [new Baz];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck25.errors.txt b/tests/baselines/reference/generatorTypeCheck25.errors.txt
new file mode 100644
index 0000000000000..8d414c7c47161
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck25.errors.txt
@@ -0,0 +1,36 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts(4,5): error TS2322: Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterable<Foo>'.
+  Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterable<Foo>'.
+    Types of property '[Symbol.iterator]' are incompatible.
+      Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterator<Foo>'.
+        Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterator<Foo>'.
+          Types of property 'next' are incompatible.
+            Type '(value?: any) => IteratorResult<Bar | Baz>' is not assignable to type '(value?: any) => IteratorResult<Foo>'.
+              Type 'IteratorResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo>'.
+                Type 'Bar | Baz' is not assignable to type 'Foo'.
+                  Type 'Baz' is not assignable to type 'Foo'.
+                    Property 'x' is missing in type 'Baz'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts (1 errors) ====
+    class Foo { x: number }
+    class Bar extends Foo { y: string }
+    class Baz { z: number }
+    var g3: () => Iterable<Foo> = function* () {
+        ~~
+!!! error TS2322: Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterable<Foo>'.
+!!! error TS2322:   Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterable<Foo>'.
+!!! error TS2322:     Types of property '[Symbol.iterator]' are incompatible.
+!!! error TS2322:       Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterator<Foo>'.
+!!! error TS2322:         Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterator<Foo>'.
+!!! error TS2322:           Types of property 'next' are incompatible.
+!!! error TS2322:             Type '(value?: any) => IteratorResult<Bar | Baz>' is not assignable to type '(value?: any) => IteratorResult<Foo>'.
+!!! error TS2322:               Type 'IteratorResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo>'.
+!!! error TS2322:                 Type 'Bar | Baz' is not assignable to type 'Foo'.
+!!! error TS2322:                   Type 'Baz' is not assignable to type 'Foo'.
+!!! error TS2322:                     Property 'x' is missing in type 'Baz'.
+        yield;
+        yield new Bar;
+        yield new Baz;
+        yield *[new Bar];
+        yield *[new Baz];
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck25.js b/tests/baselines/reference/generatorTypeCheck25.js
new file mode 100644
index 0000000000000..894561bcc9326
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck25.js
@@ -0,0 +1,26 @@
+//// [generatorTypeCheck25.ts]
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+var g3: () => Iterable<Foo> = function* () {
+    yield;
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
+
+//// [generatorTypeCheck25.js]
+class Foo {
+}
+class Bar extends Foo {
+}
+class Baz {
+}
+var g3 = function* () {
+    yield;
+    yield new Bar;
+    yield new Baz;
+    yield* [new Bar];
+    yield* [new Baz];
+};
diff --git a/tests/baselines/reference/generatorTypeCheck26.js b/tests/baselines/reference/generatorTypeCheck26.js
new file mode 100644
index 0000000000000..d5c1a4c7947e4
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck26.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck26.ts]
+function* g(): IterableIterator<(x: string) => number> {
+    yield x => x.length;
+    yield *[x => x.length];
+    return x => x.length;
+}
+
+//// [generatorTypeCheck26.js]
+function* g() {
+    yield x => x.length;
+    yield* [x => x.length];
+    return x => x.length;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols
new file mode 100644
index 0000000000000..4d3ad86256559
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck26.symbols
@@ -0,0 +1,22 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts ===
+function* g(): IterableIterator<(x: string) => number> {
+>g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
+
+    yield x => x.length;
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
+>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+
+    yield *[x => x.length];
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
+>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+
+    return x => x.length;
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
+>x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
+}
diff --git a/tests/baselines/reference/generatorTypeCheck26.types b/tests/baselines/reference/generatorTypeCheck26.types
new file mode 100644
index 0000000000000..8141a866c8e9f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck26.types
@@ -0,0 +1,30 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts ===
+function* g(): IterableIterator<(x: string) => number> {
+>g : () => IterableIterator<(x: string) => number>
+>IterableIterator : IterableIterator<T>
+>x : string
+
+    yield x => x.length;
+>yield x => x.length : any
+>x => x.length : (x: string) => number
+>x : string
+>x.length : number
+>x : string
+>length : number
+
+    yield *[x => x.length];
+>yield *[x => x.length] : any
+>[x => x.length] : ((x: string) => number)[]
+>x => x.length : (x: string) => number
+>x : string
+>x.length : number
+>x : string
+>length : number
+
+    return x => x.length;
+>x => x.length : (x: any) => any
+>x : any
+>x.length : any
+>x : any
+>length : any
+}
diff --git a/tests/baselines/reference/generatorTypeCheck27.js b/tests/baselines/reference/generatorTypeCheck27.js
new file mode 100644
index 0000000000000..528d510bed2d8
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck27.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck27.ts]
+function* g(): IterableIterator<(x: string) => number> {
+    yield * function* () {
+        yield x => x.length;
+    } ();
+}
+
+//// [generatorTypeCheck27.js]
+function* g() {
+    yield* function* () {
+        yield x => x.length;
+    }();
+}
diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols
new file mode 100644
index 0000000000000..bfff5f9e10a3f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck27.symbols
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts ===
+function* g(): IterableIterator<(x: string) => number> {
+>g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+>x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
+
+    yield * function* () {
+        yield x => x.length;
+>x : Symbol(x, Decl(generatorTypeCheck27.ts, 2, 13))
+>x : Symbol(x, Decl(generatorTypeCheck27.ts, 2, 13))
+
+    } ();
+}
diff --git a/tests/baselines/reference/generatorTypeCheck27.types b/tests/baselines/reference/generatorTypeCheck27.types
new file mode 100644
index 0000000000000..7b120cfffc47b
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck27.types
@@ -0,0 +1,21 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts ===
+function* g(): IterableIterator<(x: string) => number> {
+>g : () => IterableIterator<(x: string) => number>
+>IterableIterator : IterableIterator<T>
+>x : string
+
+    yield * function* () {
+>yield * function* () {        yield x => x.length;    } () : any
+>function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
+>function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+
+        yield x => x.length;
+>yield x => x.length : any
+>x => x.length : (x: any) => any
+>x : any
+>x.length : any
+>x : any
+>length : any
+
+    } ();
+}
diff --git a/tests/baselines/reference/generatorTypeCheck28.js b/tests/baselines/reference/generatorTypeCheck28.js
new file mode 100644
index 0000000000000..e94fd9b7e3887
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck28.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck28.ts]
+function* g(): IterableIterator<(x: string) => number> {
+    yield * {
+        *[Symbol.iterator]() {
+            yield x => x.length;
+        }
+    };
+}
+
+//// [generatorTypeCheck28.js]
+function* g() {
+    yield* {
+        *[Symbol.iterator]() {
+            yield x => x.length;
+        }
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols
new file mode 100644
index 0000000000000..e1bbbd96b401a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck28.symbols
@@ -0,0 +1,20 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts ===
+function* g(): IterableIterator<(x: string) => number> {
+>g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+>x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
+
+    yield * {
+        *[Symbol.iterator]() {
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+
+            yield x => x.length;
+>x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
+>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+        }
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck28.types b/tests/baselines/reference/generatorTypeCheck28.types
new file mode 100644
index 0000000000000..1afae07275813
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck28.types
@@ -0,0 +1,25 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts ===
+function* g(): IterableIterator<(x: string) => number> {
+>g : () => IterableIterator<(x: string) => number>
+>IterableIterator : IterableIterator<T>
+>x : string
+
+    yield * {
+>yield * {        *[Symbol.iterator]() {            yield x => x.length;        }    } : any
+>{        *[Symbol.iterator]() {            yield x => x.length;        }    } : { [Symbol.iterator](): IterableIterator<(x: string) => number>; }
+
+        *[Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+            yield x => x.length;
+>yield x => x.length : any
+>x => x.length : (x: string) => number
+>x : string
+>x.length : number
+>x : string
+>length : number
+        }
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck29.js b/tests/baselines/reference/generatorTypeCheck29.js
new file mode 100644
index 0000000000000..4f5204f89fcef
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck29.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck29.ts]
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+    yield function* () {
+        yield x => x.length;
+    } ()
+}
+
+//// [generatorTypeCheck29.js]
+function* g2() {
+    yield function* () {
+        yield x => x.length;
+    }();
+}
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
new file mode 100644
index 0000000000000..57790d5b700d4
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+>g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1662, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+>x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
+
+    yield function* () {
+        yield x => x.length;
+>x : Symbol(x, Decl(generatorTypeCheck29.ts, 2, 13))
+>x : Symbol(x, Decl(generatorTypeCheck29.ts, 2, 13))
+
+    } ()
+}
diff --git a/tests/baselines/reference/generatorTypeCheck29.types b/tests/baselines/reference/generatorTypeCheck29.types
new file mode 100644
index 0000000000000..85cb32e575931
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck29.types
@@ -0,0 +1,22 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+>g2 : () => Iterator<Iterable<(x: string) => number>>
+>Iterator : Iterator<T>
+>Iterable : Iterable<T>
+>x : string
+
+    yield function* () {
+>yield function* () {        yield x => x.length;    } () : any
+>function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
+>function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+
+        yield x => x.length;
+>yield x => x.length : any
+>x => x.length : (x: any) => any
+>x : any
+>x.length : any
+>x : any
+>length : any
+
+    } ()
+}
diff --git a/tests/baselines/reference/generatorTypeCheck3.js b/tests/baselines/reference/generatorTypeCheck3.js
new file mode 100644
index 0000000000000..9d884a92f5e4b
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck3.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck3.ts]
+function* g1(): IterableIterator<string> { }
+
+//// [generatorTypeCheck3.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck3.symbols b/tests/baselines/reference/generatorTypeCheck3.symbols
new file mode 100644
index 0000000000000..2f5d2405507d0
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck3.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts ===
+function* g1(): IterableIterator<string> { }
+>g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 1672, 1))
+
diff --git a/tests/baselines/reference/generatorTypeCheck3.types b/tests/baselines/reference/generatorTypeCheck3.types
new file mode 100644
index 0000000000000..9d2fb9d517dcd
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck3.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts ===
+function* g1(): IterableIterator<string> { }
+>g1 : () => IterableIterator<string>
+>IterableIterator : IterableIterator<T>
+
diff --git a/tests/baselines/reference/generatorTypeCheck30.js b/tests/baselines/reference/generatorTypeCheck30.js
new file mode 100644
index 0000000000000..e652dd1b55fff
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck30.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck30.ts]
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+    yield function* () {
+        yield x => x.length;
+    } ()
+}
+
+//// [generatorTypeCheck30.js]
+function* g2() {
+    yield function* () {
+        yield x => x.length;
+    }();
+}
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
new file mode 100644
index 0000000000000..49c43ce135f84
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+>g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1662, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+>x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
+
+    yield function* () {
+        yield x => x.length;
+>x : Symbol(x, Decl(generatorTypeCheck30.ts, 2, 13))
+>x : Symbol(x, Decl(generatorTypeCheck30.ts, 2, 13))
+
+    } ()
+}
diff --git a/tests/baselines/reference/generatorTypeCheck30.types b/tests/baselines/reference/generatorTypeCheck30.types
new file mode 100644
index 0000000000000..2ed94dff53187
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck30.types
@@ -0,0 +1,22 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+>g2 : () => Iterator<Iterable<(x: string) => number>>
+>Iterator : Iterator<T>
+>Iterable : Iterable<T>
+>x : string
+
+    yield function* () {
+>yield function* () {        yield x => x.length;    } () : any
+>function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
+>function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+
+        yield x => x.length;
+>yield x => x.length : any
+>x => x.length : (x: any) => any
+>x : any
+>x.length : any
+>x : any
+>length : any
+
+    } ()
+}
diff --git a/tests/baselines/reference/generatorTypeCheck31.errors.txt b/tests/baselines/reference/generatorTypeCheck31.errors.txt
new file mode 100644
index 0000000000000..a0336b464a4b2
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck31.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts(2,11): error TS2322: Type 'IterableIterator<(x: any) => any>' is not assignable to type '() => Iterable<(x: string) => number>'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts (1 errors) ====
+    function* g2(): Iterator<() => Iterable<(x: string) => number>> {
+        yield function* () {
+              ~~~~~~~~~~~~~~
+            yield x => x.length;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        } ()
+    ~~~~~~~~
+!!! error TS2322: Type 'IterableIterator<(x: any) => any>' is not assignable to type '() => Iterable<(x: string) => number>'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck31.js b/tests/baselines/reference/generatorTypeCheck31.js
new file mode 100644
index 0000000000000..2037b0ec621ef
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck31.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck31.ts]
+function* g2(): Iterator<() => Iterable<(x: string) => number>> {
+    yield function* () {
+        yield x => x.length;
+    } ()
+}
+
+//// [generatorTypeCheck31.js]
+function* g2() {
+    yield function* () {
+        yield x => x.length;
+    }();
+}
diff --git a/tests/baselines/reference/generatorTypeCheck32.errors.txt b/tests/baselines/reference/generatorTypeCheck32.errors.txt
new file mode 100644
index 0000000000000..9312371d7ebc8
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck32.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck32.ts(2,29): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck32.ts (1 errors) ====
+    var s: string;
+    var f: () => number = () => yield s;
+                                ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck32.js b/tests/baselines/reference/generatorTypeCheck32.js
new file mode 100644
index 0000000000000..5ec8e9214f328
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck32.js
@@ -0,0 +1,7 @@
+//// [generatorTypeCheck32.ts]
+var s: string;
+var f: () => number = () => yield s;
+
+//// [generatorTypeCheck32.js]
+var s;
+var f = () => yield s;
diff --git a/tests/baselines/reference/generatorTypeCheck33.js b/tests/baselines/reference/generatorTypeCheck33.js
new file mode 100644
index 0000000000000..256e4c94be75b
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck33.js
@@ -0,0 +1,15 @@
+//// [generatorTypeCheck33.ts]
+function* g() {
+    yield 0;
+    function* g2() {
+        yield "";
+    }
+}
+
+//// [generatorTypeCheck33.js]
+function* g() {
+    yield 0;
+    function* g2() {
+        yield "";
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck33.symbols b/tests/baselines/reference/generatorTypeCheck33.symbols
new file mode 100644
index 0000000000000..b1bda8808f2e4
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck33.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck33.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck33.ts, 0, 0))
+
+    yield 0;
+    function* g2() {
+>g2 : Symbol(g2, Decl(generatorTypeCheck33.ts, 1, 12))
+
+        yield "";
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck33.types b/tests/baselines/reference/generatorTypeCheck33.types
new file mode 100644
index 0000000000000..f3b8af225d1c1
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck33.types
@@ -0,0 +1,16 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck33.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+
+    function* g2() {
+>g2 : () => IterableIterator<string>
+
+        yield "";
+>yield "" : any
+>"" : string
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck34.js b/tests/baselines/reference/generatorTypeCheck34.js
new file mode 100644
index 0000000000000..20b88b9a090b8
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck34.js
@@ -0,0 +1,15 @@
+//// [generatorTypeCheck34.ts]
+function* g() {
+    yield 0;
+    function* g2() {
+        return "";
+    }
+}
+
+//// [generatorTypeCheck34.js]
+function* g() {
+    yield 0;
+    function* g2() {
+        return "";
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck34.symbols b/tests/baselines/reference/generatorTypeCheck34.symbols
new file mode 100644
index 0000000000000..343b68c3bda53
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck34.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck34.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck34.ts, 0, 0))
+
+    yield 0;
+    function* g2() {
+>g2 : Symbol(g2, Decl(generatorTypeCheck34.ts, 1, 12))
+
+        return "";
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck34.types b/tests/baselines/reference/generatorTypeCheck34.types
new file mode 100644
index 0000000000000..35063e988ebdb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck34.types
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck34.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+
+    function* g2() {
+>g2 : () => IterableIterator<any>
+
+        return "";
+>"" : string
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck35.js b/tests/baselines/reference/generatorTypeCheck35.js
new file mode 100644
index 0000000000000..e2b1c10850a75
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck35.js
@@ -0,0 +1,15 @@
+//// [generatorTypeCheck35.ts]
+function* g() {
+    yield 0;
+    function g2() {
+        return "";
+    }
+}
+
+//// [generatorTypeCheck35.js]
+function* g() {
+    yield 0;
+    function g2() {
+        return "";
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck35.symbols b/tests/baselines/reference/generatorTypeCheck35.symbols
new file mode 100644
index 0000000000000..43271b79e9ed7
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck35.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck35.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck35.ts, 0, 0))
+
+    yield 0;
+    function g2() {
+>g2 : Symbol(g2, Decl(generatorTypeCheck35.ts, 1, 12))
+
+        return "";
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck35.types b/tests/baselines/reference/generatorTypeCheck35.types
new file mode 100644
index 0000000000000..0bfc22ab3f090
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck35.types
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck35.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+
+    function g2() {
+>g2 : () => string
+
+        return "";
+>"" : string
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck36.js b/tests/baselines/reference/generatorTypeCheck36.js
new file mode 100644
index 0000000000000..a207860603b45
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck36.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck36.ts]
+function* g() {
+    yield yield 0;
+}
+
+//// [generatorTypeCheck36.js]
+function* g() {
+    yield yield 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck36.symbols b/tests/baselines/reference/generatorTypeCheck36.symbols
new file mode 100644
index 0000000000000..dc7eb37fe30bc
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck36.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck36.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck36.ts, 0, 0))
+
+    yield yield 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck36.types b/tests/baselines/reference/generatorTypeCheck36.types
new file mode 100644
index 0000000000000..110a4d3e02e0a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck36.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck36.ts ===
+function* g() {
+>g : () => IterableIterator<any>
+
+    yield yield 0;
+>yield yield 0 : any
+>yield 0 : any
+>0 : number
+}
diff --git a/tests/baselines/reference/generatorTypeCheck37.js b/tests/baselines/reference/generatorTypeCheck37.js
new file mode 100644
index 0000000000000..4c73dfe558a31
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck37.js
@@ -0,0 +1,9 @@
+//// [generatorTypeCheck37.ts]
+function* g() {
+    return yield yield 0;
+}
+
+//// [generatorTypeCheck37.js]
+function* g() {
+    return yield yield 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck37.symbols b/tests/baselines/reference/generatorTypeCheck37.symbols
new file mode 100644
index 0000000000000..8939c5382e239
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck37.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck37.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck37.ts, 0, 0))
+
+    return yield yield 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck37.types b/tests/baselines/reference/generatorTypeCheck37.types
new file mode 100644
index 0000000000000..e8611ec167ad4
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck37.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck37.ts ===
+function* g() {
+>g : () => IterableIterator<any>
+
+    return yield yield 0;
+>yield yield 0 : any
+>yield 0 : any
+>0 : number
+}
diff --git a/tests/baselines/reference/generatorTypeCheck38.js b/tests/baselines/reference/generatorTypeCheck38.js
new file mode 100644
index 0000000000000..de5258db7858f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck38.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck38.ts]
+var yield;
+function* g() {
+    yield 0;
+    var v: typeof yield;
+}
+
+//// [generatorTypeCheck38.js]
+var yield;
+function* g() {
+    yield 0;
+    var v;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck38.symbols b/tests/baselines/reference/generatorTypeCheck38.symbols
new file mode 100644
index 0000000000000..83410159b1a91
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck38.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck38.ts ===
+var yield;
+>yield : Symbol(yield, Decl(generatorTypeCheck38.ts, 0, 3))
+
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck38.ts, 0, 10))
+
+    yield 0;
+    var v: typeof yield;
+>v : Symbol(v, Decl(generatorTypeCheck38.ts, 3, 7))
+>yield : Symbol(yield, Decl(generatorTypeCheck38.ts, 0, 3))
+}
diff --git a/tests/baselines/reference/generatorTypeCheck38.types b/tests/baselines/reference/generatorTypeCheck38.types
new file mode 100644
index 0000000000000..08503e8640f4b
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck38.types
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck38.ts ===
+var yield;
+>yield : any
+
+function* g() {
+>g : () => IterableIterator<number>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+
+    var v: typeof yield;
+>v : any
+>yield : any
+}
diff --git a/tests/baselines/reference/generatorTypeCheck39.errors.txt b/tests/baselines/reference/generatorTypeCheck39.errors.txt
new file mode 100644
index 0000000000000..e44812cef0d04
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck39.errors.txt
@@ -0,0 +1,27 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,5): error TS1129: Statement expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,6): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,16): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,22): error TS1005: ',' expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(9,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts (5 errors) ====
+    function decorator(x: any) {
+        return y => { };
+    }
+    function* g() {
+        @decorator(yield 0)
+        ~
+!!! error TS1129: Statement expected.
+         ~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+                   ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+                         ~
+!!! error TS1005: ',' expected.
+        class C {
+            x = yield 0;
+        }
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck39.js b/tests/baselines/reference/generatorTypeCheck39.js
new file mode 100644
index 0000000000000..0fbf5e2cfe691
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck39.js
@@ -0,0 +1,32 @@
+//// [generatorTypeCheck39.ts]
+function decorator(x: any) {
+    return y => { };
+}
+function* g() {
+    @decorator(yield 0)
+    class C {
+        x = yield 0;
+    }
+}
+
+//// [generatorTypeCheck39.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
+function decorator(x) {
+    return y => { };
+}
+function* g() { }
+let C = class {
+    constructor() {
+        this.x = yield 0;
+    }
+};
+C = __decorate([
+    decorator(yield, 0)
+], C);
diff --git a/tests/baselines/reference/generatorTypeCheck4.js b/tests/baselines/reference/generatorTypeCheck4.js
new file mode 100644
index 0000000000000..8c0d7aeddd158
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck4.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck4.ts]
+function* g1(): {} { }
+
+//// [generatorTypeCheck4.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck4.symbols b/tests/baselines/reference/generatorTypeCheck4.symbols
new file mode 100644
index 0000000000000..fb7cd93e0d9cd
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck4.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck4.ts ===
+function* g1(): {} { }
+>g1 : Symbol(g1, Decl(generatorTypeCheck4.ts, 0, 0))
+
diff --git a/tests/baselines/reference/generatorTypeCheck4.types b/tests/baselines/reference/generatorTypeCheck4.types
new file mode 100644
index 0000000000000..c90fda0c0fcc1
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck4.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck4.ts ===
+function* g1(): {} { }
+>g1 : () => {}
+
diff --git a/tests/baselines/reference/generatorTypeCheck40.errors.txt b/tests/baselines/reference/generatorTypeCheck40.errors.txt
new file mode 100644
index 0000000000000..4d3880ad4aa2f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck40.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,21): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts (2 errors) ====
+    function* g() {
+        class C extends (yield 0) { }
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+                        ~~~~~~~~~
+!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck40.js b/tests/baselines/reference/generatorTypeCheck40.js
new file mode 100644
index 0000000000000..fe9bb797d778f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck40.js
@@ -0,0 +1,10 @@
+//// [generatorTypeCheck40.ts]
+function* g() {
+    class C extends (yield 0) { }
+}
+
+//// [generatorTypeCheck40.js]
+function* g() {
+    class C extends (yield 0) {
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck41.js b/tests/baselines/reference/generatorTypeCheck41.js
new file mode 100644
index 0000000000000..51c5ce3d4167f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck41.js
@@ -0,0 +1,13 @@
+//// [generatorTypeCheck41.ts]
+function* g() {
+    let x = {
+        [yield 0]: 0
+    }
+}
+
+//// [generatorTypeCheck41.js]
+function* g() {
+    let x = {
+        [yield 0]: 0
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck41.symbols b/tests/baselines/reference/generatorTypeCheck41.symbols
new file mode 100644
index 0000000000000..9111affa87569
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck41.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck41.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck41.ts, 0, 0))
+
+    let x = {
+>x : Symbol(x, Decl(generatorTypeCheck41.ts, 1, 7))
+
+        [yield 0]: 0
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck41.types b/tests/baselines/reference/generatorTypeCheck41.types
new file mode 100644
index 0000000000000..926aef95ce576
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck41.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck41.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    let x = {
+>x : {}
+>{        [yield 0]: 0    } : {}
+
+        [yield 0]: 0
+>yield 0 : any
+>0 : number
+>0 : number
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck42.js b/tests/baselines/reference/generatorTypeCheck42.js
new file mode 100644
index 0000000000000..c58802b1a8163
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck42.js
@@ -0,0 +1,16 @@
+//// [generatorTypeCheck42.ts]
+function* g() {
+    let x = {
+        [yield 0]() {
+
+        }
+    }
+}
+
+//// [generatorTypeCheck42.js]
+function* g() {
+    let x = {
+        [yield 0]() {
+        }
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck42.symbols b/tests/baselines/reference/generatorTypeCheck42.symbols
new file mode 100644
index 0000000000000..a49534fd21112
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck42.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck42.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck42.ts, 0, 0))
+
+    let x = {
+>x : Symbol(x, Decl(generatorTypeCheck42.ts, 1, 7))
+
+        [yield 0]() {
+
+        }
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck42.types b/tests/baselines/reference/generatorTypeCheck42.types
new file mode 100644
index 0000000000000..855c4697f4099
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck42.types
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck42.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    let x = {
+>x : {}
+>{        [yield 0]() {        }    } : {}
+
+        [yield 0]() {
+>yield 0 : any
+>0 : number
+
+        }
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck43.js b/tests/baselines/reference/generatorTypeCheck43.js
new file mode 100644
index 0000000000000..c7dc2dad39349
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck43.js
@@ -0,0 +1,16 @@
+//// [generatorTypeCheck43.ts]
+function* g() {
+    let x = {
+        *[yield 0]() {
+
+        }
+    }
+}
+
+//// [generatorTypeCheck43.js]
+function* g() {
+    let x = {
+        *[yield 0]() {
+        }
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck43.symbols b/tests/baselines/reference/generatorTypeCheck43.symbols
new file mode 100644
index 0000000000000..f5f7b6c359f44
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck43.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck43.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck43.ts, 0, 0))
+
+    let x = {
+>x : Symbol(x, Decl(generatorTypeCheck43.ts, 1, 7))
+
+        *[yield 0]() {
+
+        }
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck43.types b/tests/baselines/reference/generatorTypeCheck43.types
new file mode 100644
index 0000000000000..50fc7e30c864a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck43.types
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck43.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    let x = {
+>x : {}
+>{        *[yield 0]() {        }    } : {}
+
+        *[yield 0]() {
+>yield 0 : any
+>0 : number
+
+        }
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck44.js b/tests/baselines/reference/generatorTypeCheck44.js
new file mode 100644
index 0000000000000..238998ad9742e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck44.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck44.ts]
+function* g() {
+    let x = {
+        get [yield 0]() {
+            return 0;
+        }
+    }
+}
+
+//// [generatorTypeCheck44.js]
+function* g() {
+    let x = {
+        get [yield 0]() {
+            return 0;
+        }
+    };
+}
diff --git a/tests/baselines/reference/generatorTypeCheck44.symbols b/tests/baselines/reference/generatorTypeCheck44.symbols
new file mode 100644
index 0000000000000..b6606064c438a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck44.symbols
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck44.ts ===
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck44.ts, 0, 0))
+
+    let x = {
+>x : Symbol(x, Decl(generatorTypeCheck44.ts, 1, 7))
+
+        get [yield 0]() {
+            return 0;
+        }
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck44.types b/tests/baselines/reference/generatorTypeCheck44.types
new file mode 100644
index 0000000000000..2fc67f90556ba
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck44.types
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck44.ts ===
+function* g() {
+>g : () => IterableIterator<number>
+
+    let x = {
+>x : {}
+>{        get [yield 0]() {            return 0;        }    } : {}
+
+        get [yield 0]() {
+>yield 0 : any
+>0 : number
+
+            return 0;
+>0 : number
+        }
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck45.js b/tests/baselines/reference/generatorTypeCheck45.js
new file mode 100644
index 0000000000000..20f64e53c9d60
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck45.js
@@ -0,0 +1,7 @@
+//// [generatorTypeCheck45.ts]
+declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T): T;
+
+foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
+
+//// [generatorTypeCheck45.js]
+foo("", function* () { yield x => x.length; }, p => undefined); // T is fixed, should be string
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
new file mode 100644
index 0000000000000..06340925fecac
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -0,0 +1,27 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck45.ts ===
+declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T): T;
+>foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0))
+>T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
+>U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
+>x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27))
+>T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
+>fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 1662, 1))
+>x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54))
+>T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
+>U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
+>fun2 : Symbol(fun2, Decl(generatorTypeCheck45.ts, 0, 66))
+>y : Symbol(y, Decl(generatorTypeCheck45.ts, 0, 74))
+>U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
+>T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
+>T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
+
+foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
+>foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0))
+>x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
+>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p : Symbol(p, Decl(generatorTypeCheck45.ts, 2, 45))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/generatorTypeCheck45.types b/tests/baselines/reference/generatorTypeCheck45.types
new file mode 100644
index 0000000000000..7ea442420d697
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck45.types
@@ -0,0 +1,33 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck45.ts ===
+declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T): T;
+>foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T) => T
+>T : T
+>U : U
+>x : T
+>T : T
+>fun : () => Iterator<(x: T) => U>
+>Iterator : Iterator<T>
+>x : T
+>T : T
+>U : U
+>fun2 : (y: U) => T
+>y : U
+>U : U
+>T : T
+>T : T
+
+foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
+>foo("", function* () { yield x => x.length }, p => undefined) : string
+>foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T) => T
+>"" : string
+>function* () { yield x => x.length } : () => IterableIterator<(x: string) => number>
+>yield x => x.length : any
+>x => x.length : (x: string) => number
+>x : string
+>x.length : number
+>x : string
+>length : number
+>p => undefined : (p: number) => any
+>p : number
+>undefined : undefined
+
diff --git a/tests/baselines/reference/generatorTypeCheck46.js b/tests/baselines/reference/generatorTypeCheck46.js
new file mode 100644
index 0000000000000..0270f9e3a3351
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck46.js
@@ -0,0 +1,19 @@
+//// [generatorTypeCheck46.ts]
+declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T): T;
+
+foo("", function* () {
+    yield* {
+        *[Symbol.iterator]() {
+            yield x => x.length
+        }
+    }
+}, p => undefined); // T is fixed, should be string
+
+//// [generatorTypeCheck46.js]
+foo("", function* () {
+    yield* {
+        *[Symbol.iterator]() {
+            yield x => x.length;
+        }
+    };
+}, p => undefined); // T is fixed, should be string
diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols
new file mode 100644
index 0000000000000..aa0b237d1f2fb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck46.symbols
@@ -0,0 +1,38 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck46.ts ===
+declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T): T;
+>foo : Symbol(foo, Decl(generatorTypeCheck46.ts, 0, 0))
+>T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
+>U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))
+>x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27))
+>T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
+>fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
+>x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54))
+>T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
+>U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))
+>fun2 : Symbol(fun2, Decl(generatorTypeCheck46.ts, 0, 66))
+>y : Symbol(y, Decl(generatorTypeCheck46.ts, 0, 74))
+>U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))
+>T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
+>T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
+
+foo("", function* () {
+>foo : Symbol(foo, Decl(generatorTypeCheck46.ts, 0, 0))
+
+    yield* {
+        *[Symbol.iterator]() {
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+
+            yield x => x.length
+>x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
+>x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+        }
+    }
+}, p => undefined); // T is fixed, should be string
+>p : Symbol(p, Decl(generatorTypeCheck46.ts, 8, 2))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/generatorTypeCheck46.types b/tests/baselines/reference/generatorTypeCheck46.types
new file mode 100644
index 0000000000000..daf0d67b6ecb6
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck46.types
@@ -0,0 +1,47 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck46.ts ===
+declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T): T;
+>foo : <T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T) => T
+>T : T
+>U : U
+>x : T
+>T : T
+>fun : () => Iterable<(x: T) => U>
+>Iterable : Iterable<T>
+>x : T
+>T : T
+>U : U
+>fun2 : (y: U) => T
+>y : U
+>U : U
+>T : T
+>T : T
+
+foo("", function* () {
+>foo("", function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }}, p => undefined) : string
+>foo : <T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T) => T
+>"" : string
+>function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }} : () => IterableIterator<(x: string) => number>
+
+    yield* {
+>yield* {        *[Symbol.iterator]() {            yield x => x.length        }    } : any
+>{        *[Symbol.iterator]() {            yield x => x.length        }    } : { [Symbol.iterator](): IterableIterator<(x: string) => number>; }
+
+        *[Symbol.iterator]() {
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+            yield x => x.length
+>yield x => x.length : any
+>x => x.length : (x: string) => number
+>x : string
+>x.length : number
+>x : string
+>length : number
+        }
+    }
+}, p => undefined); // T is fixed, should be string
+>p => undefined : (p: number) => any
+>p : number
+>undefined : undefined
+
diff --git a/tests/baselines/reference/generatorTypeCheck47.errors.txt b/tests/baselines/reference/generatorTypeCheck47.errors.txt
new file mode 100644
index 0000000000000..f5264f7ce9607
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck47.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts (1 errors) ====
+    
+    function* g() { }
+            ~
+!!! error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck47.js b/tests/baselines/reference/generatorTypeCheck47.js
new file mode 100644
index 0000000000000..b06fb96b43513
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck47.js
@@ -0,0 +1,6 @@
+//// [generatorTypeCheck47.ts]
+
+function* g() { }
+
+//// [generatorTypeCheck47.js]
+function* g() { }
diff --git a/tests/baselines/reference/generatorTypeCheck48.errors.txt b/tests/baselines/reference/generatorTypeCheck48.errors.txt
new file mode 100644
index 0000000000000..c91626cd813cb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck48.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts (1 errors) ====
+    
+    function* g() {
+            ~
+!!! error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
+        yield;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck48.js b/tests/baselines/reference/generatorTypeCheck48.js
new file mode 100644
index 0000000000000..579d6dcf0e1ca
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck48.js
@@ -0,0 +1,10 @@
+//// [generatorTypeCheck48.ts]
+
+function* g() {
+    yield;
+}
+
+//// [generatorTypeCheck48.js]
+function* g() {
+    yield;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck49.js b/tests/baselines/reference/generatorTypeCheck49.js
new file mode 100644
index 0000000000000..b544c7e422535
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck49.js
@@ -0,0 +1,10 @@
+//// [generatorTypeCheck49.ts]
+
+function* g() {
+    yield 0;
+}
+
+//// [generatorTypeCheck49.js]
+function* g() {
+    yield 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck49.symbols b/tests/baselines/reference/generatorTypeCheck49.symbols
new file mode 100644
index 0000000000000..d24deed3d803d
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck49.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts ===
+
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck49.ts, 0, 0))
+
+    yield 0;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck49.types b/tests/baselines/reference/generatorTypeCheck49.types
new file mode 100644
index 0000000000000..f56cca33438fb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck49.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts ===
+
+function* g() {
+>g : () => IterableIterator<number>
+
+    yield 0;
+>yield 0 : any
+>0 : number
+}
diff --git a/tests/baselines/reference/generatorTypeCheck5.js b/tests/baselines/reference/generatorTypeCheck5.js
new file mode 100644
index 0000000000000..1acfc11057818
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck5.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck5.ts]
+function* g1(): any { }
+
+//// [generatorTypeCheck5.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck5.symbols b/tests/baselines/reference/generatorTypeCheck5.symbols
new file mode 100644
index 0000000000000..3f889e3cadfa8
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck5.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck5.ts ===
+function* g1(): any { }
+>g1 : Symbol(g1, Decl(generatorTypeCheck5.ts, 0, 0))
+
diff --git a/tests/baselines/reference/generatorTypeCheck5.types b/tests/baselines/reference/generatorTypeCheck5.types
new file mode 100644
index 0000000000000..6918a00663ca4
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck5.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck5.ts ===
+function* g1(): any { }
+>g1 : () => any
+
diff --git a/tests/baselines/reference/generatorTypeCheck50.js b/tests/baselines/reference/generatorTypeCheck50.js
new file mode 100644
index 0000000000000..856e3867ab6bc
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck50.js
@@ -0,0 +1,10 @@
+//// [generatorTypeCheck50.ts]
+
+function* g() {
+    yield yield;
+}
+
+//// [generatorTypeCheck50.js]
+function* g() {
+    yield yield;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck50.symbols b/tests/baselines/reference/generatorTypeCheck50.symbols
new file mode 100644
index 0000000000000..412a1ac1ea7cc
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck50.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts ===
+
+function* g() {
+>g : Symbol(g, Decl(generatorTypeCheck50.ts, 0, 0))
+
+    yield yield;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck50.types b/tests/baselines/reference/generatorTypeCheck50.types
new file mode 100644
index 0000000000000..342d7406dce0e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck50.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts ===
+
+function* g() {
+>g : () => IterableIterator<any>
+
+    yield yield;
+>yield yield : any
+>yield : any
+}
diff --git a/tests/baselines/reference/generatorTypeCheck51.errors.txt b/tests/baselines/reference/generatorTypeCheck51.errors.txt
new file mode 100644
index 0000000000000..f4fc5723a5ece
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck51.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts(2,9): error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts (1 errors) ====
+    
+    function* g() {
+            ~
+!!! error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
+        function* h() {
+            yield 0;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck51.js b/tests/baselines/reference/generatorTypeCheck51.js
new file mode 100644
index 0000000000000..f3519065c3d25
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck51.js
@@ -0,0 +1,14 @@
+//// [generatorTypeCheck51.ts]
+
+function* g() {
+    function* h() {
+        yield 0;
+    }
+}
+
+//// [generatorTypeCheck51.js]
+function* g() {
+    function* h() {
+        yield 0;
+    }
+}
diff --git a/tests/baselines/reference/generatorTypeCheck52.errors.txt b/tests/baselines/reference/generatorTypeCheck52.errors.txt
new file mode 100644
index 0000000000000..8dc280bb8c94a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck52.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck52.ts(3,11): error TS2504: No best common type exists among yield expressions.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck52.ts (1 errors) ====
+    class Foo { x: number }
+    class Baz { z: number }
+    function* g() {
+              ~
+!!! error TS2504: No best common type exists among yield expressions.
+        yield new Foo;
+        yield new Baz;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck52.js b/tests/baselines/reference/generatorTypeCheck52.js
new file mode 100644
index 0000000000000..751e12c471f9e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck52.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck52.ts]
+class Foo { x: number }
+class Baz { z: number }
+function* g() {
+    yield new Foo;
+    yield new Baz;
+}
+
+//// [generatorTypeCheck52.js]
+class Foo {
+}
+class Baz {
+}
+function* g() {
+    yield new Foo;
+    yield new Baz;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck53.errors.txt b/tests/baselines/reference/generatorTypeCheck53.errors.txt
new file mode 100644
index 0000000000000..ee3512f34c584
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck53.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck53.ts(3,11): error TS2504: No best common type exists among yield expressions.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck53.ts (1 errors) ====
+    class Foo { x: number }
+    class Baz { z: number }
+    function* g() {
+              ~
+!!! error TS2504: No best common type exists among yield expressions.
+        yield new Foo;
+        yield* [new Baz];
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck53.js b/tests/baselines/reference/generatorTypeCheck53.js
new file mode 100644
index 0000000000000..f26b3b60806e0
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck53.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck53.ts]
+class Foo { x: number }
+class Baz { z: number }
+function* g() {
+    yield new Foo;
+    yield* [new Baz];
+}
+
+//// [generatorTypeCheck53.js]
+class Foo {
+}
+class Baz {
+}
+function* g() {
+    yield new Foo;
+    yield* [new Baz];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck54.errors.txt b/tests/baselines/reference/generatorTypeCheck54.errors.txt
new file mode 100644
index 0000000000000..de22dbfc6e812
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck54.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck54.ts(3,11): error TS2504: No best common type exists among yield expressions.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck54.ts (1 errors) ====
+    class Foo { x: number }
+    class Baz { z: number }
+    function* g() {
+              ~
+!!! error TS2504: No best common type exists among yield expressions.
+        yield* [new Foo];
+        yield* [new Baz];
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck54.js b/tests/baselines/reference/generatorTypeCheck54.js
new file mode 100644
index 0000000000000..f53215404efde
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck54.js
@@ -0,0 +1,17 @@
+//// [generatorTypeCheck54.ts]
+class Foo { x: number }
+class Baz { z: number }
+function* g() {
+    yield* [new Foo];
+    yield* [new Baz];
+}
+
+//// [generatorTypeCheck54.js]
+class Foo {
+}
+class Baz {
+}
+function* g() {
+    yield* [new Foo];
+    yield* [new Baz];
+}
diff --git a/tests/baselines/reference/generatorTypeCheck55.errors.txt b/tests/baselines/reference/generatorTypeCheck55.errors.txt
new file mode 100644
index 0000000000000..0846d1c28adaa
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck55.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts(2,19): error TS9003: 'class' expressions are not currently supported.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts (1 errors) ====
+    function* g() {
+        var x = class C extends (yield) {};
+                      ~
+!!! error TS9003: 'class' expressions are not currently supported.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck55.js b/tests/baselines/reference/generatorTypeCheck55.js
new file mode 100644
index 0000000000000..dd7cd33af2945
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck55.js
@@ -0,0 +1,11 @@
+//// [generatorTypeCheck55.ts]
+function* g() {
+    var x = class C extends (yield) {};
+}
+
+//// [generatorTypeCheck55.js]
+function* g() {
+    var x = class C extends (yield) {
+    }
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck56.errors.txt b/tests/baselines/reference/generatorTypeCheck56.errors.txt
new file mode 100644
index 0000000000000..99e3b00de41f1
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck56.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts(2,19): error TS9003: 'class' expressions are not currently supported.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts(3,11): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts (2 errors) ====
+    function* g() {
+        var x = class C {
+                      ~
+!!! error TS9003: 'class' expressions are not currently supported.
+            *[yield 0]() {
+              ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
+                yield 0;
+            }
+        };
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck56.js b/tests/baselines/reference/generatorTypeCheck56.js
new file mode 100644
index 0000000000000..c1b0f98f5e73f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck56.js
@@ -0,0 +1,18 @@
+//// [generatorTypeCheck56.ts]
+function* g() {
+    var x = class C {
+        *[yield 0]() {
+            yield 0;
+        }
+    };
+}
+
+//// [generatorTypeCheck56.js]
+function* g() {
+    var x = class C {
+        *[yield 0]() {
+            yield 0;
+        }
+    }
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck57.errors.txt b/tests/baselines/reference/generatorTypeCheck57.errors.txt
new file mode 100644
index 0000000000000..c2fe00d736583
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck57.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts(3,13): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts (2 errors) ====
+    function* g() {
+        class C {
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+            x = yield 0;
+                ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
+        };
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck57.js b/tests/baselines/reference/generatorTypeCheck57.js
new file mode 100644
index 0000000000000..740df49286782
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck57.js
@@ -0,0 +1,16 @@
+//// [generatorTypeCheck57.ts]
+function* g() {
+    class C {
+        x = yield 0;
+    };
+}
+
+//// [generatorTypeCheck57.js]
+function* g() {
+    class C {
+        constructor() {
+            this.x = yield 0;
+        }
+    }
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck58.errors.txt b/tests/baselines/reference/generatorTypeCheck58.errors.txt
new file mode 100644
index 0000000000000..bc8ed7694108c
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck58.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts(3,20): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts (2 errors) ====
+    function* g() {
+        class C {
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+            static x = yield 0;
+                       ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
+        };
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck58.js b/tests/baselines/reference/generatorTypeCheck58.js
new file mode 100644
index 0000000000000..925fc2b76d26d
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck58.js
@@ -0,0 +1,14 @@
+//// [generatorTypeCheck58.ts]
+function* g() {
+    class C {
+        static x = yield 0;
+    };
+}
+
+//// [generatorTypeCheck58.js]
+function* g() {
+    class C {
+    }
+    C.x = yield 0;
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck59.errors.txt b/tests/baselines/reference/generatorTypeCheck59.errors.txt
new file mode 100644
index 0000000000000..3368b79d9915a
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck59.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts(3,11): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts (2 errors) ====
+    function* g() {
+        class C {
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+            @(yield "")
+              ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
+            m() { }
+        };
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck59.js b/tests/baselines/reference/generatorTypeCheck59.js
new file mode 100644
index 0000000000000..5b3b70386f894
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck59.js
@@ -0,0 +1,27 @@
+//// [generatorTypeCheck59.ts]
+function* g() {
+    class C {
+        @(yield "")
+        m() { }
+    };
+}
+
+//// [generatorTypeCheck59.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
+function* g() {
+    class C {
+        m() { }
+    }
+    Object.defineProperty(C.prototype, "m",
+        __decorate([
+            (yield "")
+        ], C.prototype, "m", Object.getOwnPropertyDescriptor(C.prototype, "m")));
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck6.errors.txt b/tests/baselines/reference/generatorTypeCheck6.errors.txt
new file mode 100644
index 0000000000000..35f2cc2016dbc
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts(1,17): error TS2322: Type 'IterableIterator<any>' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts (1 errors) ====
+    function* g1(): number { }
+                    ~~~~~~
+!!! error TS2322: Type 'IterableIterator<any>' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck6.js b/tests/baselines/reference/generatorTypeCheck6.js
new file mode 100644
index 0000000000000..de0f92f77f14e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck6.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck6.ts]
+function* g1(): number { }
+
+//// [generatorTypeCheck6.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck60.errors.txt b/tests/baselines/reference/generatorTypeCheck60.errors.txt
new file mode 100644
index 0000000000000..39724d9ac6d1f
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck60.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,21): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts (2 errors) ====
+    function* g() {
+        class C extends (yield) {};
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+                        ~~~~~~~
+!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck60.js b/tests/baselines/reference/generatorTypeCheck60.js
new file mode 100644
index 0000000000000..cb7c65cf081cd
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck60.js
@@ -0,0 +1,11 @@
+//// [generatorTypeCheck60.ts]
+function* g() {
+    class C extends (yield) {};
+}
+
+//// [generatorTypeCheck60.js]
+function* g() {
+    class C extends (yield) {
+    }
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck61.errors.txt b/tests/baselines/reference/generatorTypeCheck61.errors.txt
new file mode 100644
index 0000000000000..3c9f3819d61f3
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck61.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts(2,5): error TS1129: Statement expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts(2,12): error TS1146: Declaration expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts(2,13): error TS1005: ')' expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts(2,14): error TS1005: ';' expected.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts(4,1): error TS1128: Declaration or statement expected.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts (5 errors) ====
+    function * g() {
+        @(yield 0)
+        ~
+!!! error TS1129: Statement expected.
+               
+!!! error TS1146: Declaration expected.
+                ~
+!!! error TS1005: ')' expected.
+                 ~
+!!! error TS1005: ';' expected.
+        class C {};
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck61.js b/tests/baselines/reference/generatorTypeCheck61.js
new file mode 100644
index 0000000000000..591e52f269e5e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck61.js
@@ -0,0 +1,12 @@
+//// [generatorTypeCheck61.ts]
+function * g() {
+    @(yield 0)
+    class C {};
+}
+
+//// [generatorTypeCheck61.js]
+function* g() { }
+0;
+class C {
+}
+;
diff --git a/tests/baselines/reference/generatorTypeCheck7.errors.txt b/tests/baselines/reference/generatorTypeCheck7.errors.txt
new file mode 100644
index 0000000000000..2653ecf8cd597
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck7.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts(4,17): error TS2322: Type 'IterableIterator<number>' is not assignable to type 'WeirdIter'.
+  Property 'hello' is missing in type 'IterableIterator<number>'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts (1 errors) ====
+    interface WeirdIter extends IterableIterator<number> {
+        hello: string;
+    }
+    function* g1(): WeirdIter { }
+                    ~~~~~~~~~
+!!! error TS2322: Type 'IterableIterator<number>' is not assignable to type 'WeirdIter'.
+!!! error TS2322:   Property 'hello' is missing in type 'IterableIterator<number>'.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck7.js b/tests/baselines/reference/generatorTypeCheck7.js
new file mode 100644
index 0000000000000..c2d47f9483cca
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck7.js
@@ -0,0 +1,8 @@
+//// [generatorTypeCheck7.ts]
+interface WeirdIter extends IterableIterator<number> {
+    hello: string;
+}
+function* g1(): WeirdIter { }
+
+//// [generatorTypeCheck7.js]
+function* g1() { }
diff --git a/tests/baselines/reference/generatorTypeCheck8.errors.txt b/tests/baselines/reference/generatorTypeCheck8.errors.txt
new file mode 100644
index 0000000000000..cedfecda60b94
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck8.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts(2,17): error TS2322: Type 'IterableIterator<string>' is not assignable to type 'BadGenerator'.
+  Types of property 'next' are incompatible.
+    Type '(value?: any) => IteratorResult<string>' is not assignable to type '(value?: any) => IteratorResult<number>'.
+      Type 'IteratorResult<string>' is not assignable to type 'IteratorResult<number>'.
+        Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts (1 errors) ====
+    interface BadGenerator extends Iterator<number>, Iterable<string> { }
+    function* g3(): BadGenerator { }
+                    ~~~~~~~~~~~~
+!!! error TS2322: Type 'IterableIterator<string>' is not assignable to type 'BadGenerator'.
+!!! error TS2322:   Types of property 'next' are incompatible.
+!!! error TS2322:     Type '(value?: any) => IteratorResult<string>' is not assignable to type '(value?: any) => IteratorResult<number>'.
+!!! error TS2322:       Type 'IteratorResult<string>' is not assignable to type 'IteratorResult<number>'.
+!!! error TS2322:         Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck8.js b/tests/baselines/reference/generatorTypeCheck8.js
new file mode 100644
index 0000000000000..97058c2eaa0aa
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck8.js
@@ -0,0 +1,6 @@
+//// [generatorTypeCheck8.ts]
+interface BadGenerator extends Iterator<number>, Iterable<string> { }
+function* g3(): BadGenerator { }
+
+//// [generatorTypeCheck8.js]
+function* g3() { }
diff --git a/tests/baselines/reference/generatorTypeCheck9.errors.txt b/tests/baselines/reference/generatorTypeCheck9.errors.txt
new file mode 100644
index 0000000000000..3b4e0c654fb92
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck9.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck9.ts(1,17): error TS2505: A generator cannot have a 'void' type annotation.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck9.ts (1 errors) ====
+    function* g3(): void { }
+                    ~~~~
+!!! error TS2505: A generator cannot have a 'void' type annotation.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck9.js b/tests/baselines/reference/generatorTypeCheck9.js
new file mode 100644
index 0000000000000..3bdeec0a4a90b
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck9.js
@@ -0,0 +1,5 @@
+//// [generatorTypeCheck9.ts]
+function* g3(): void { }
+
+//// [generatorTypeCheck9.js]
+function* g3() { }
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.js b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.js
new file mode 100644
index 0000000000000..a5cf75ae7f3bf
--- /dev/null
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.js
@@ -0,0 +1,9 @@
+//// [inferentialTypingObjectLiteralMethod1.ts]
+interface Int<T, U> {
+    method(x: T): U;
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
+
+//// [inferentialTypingObjectLiteralMethod1.js]
+foo("", { method: function (p1) { return p1.length; } }, { method: function (p2) { return undefined; } });
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
new file mode 100644
index 0000000000000..3fee48fc837d2
--- /dev/null
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
@@ -0,0 +1,39 @@
+=== tests/cases/compiler/inferentialTypingObjectLiteralMethod1.ts ===
+interface Int<T, U> {
+>Int : Symbol(Int, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 0))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 14))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 16))
+
+    method(x: T): U;
+>method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 21))
+>x : Symbol(x, Decl(inferentialTypingObjectLiteralMethod1.ts, 1, 11))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 14))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 16))
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+>foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod1.ts, 2, 1))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 21))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 23))
+>x : Symbol(x, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 27))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 21))
+>y : Symbol(y, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 32))
+>Int : Symbol(Int, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 0))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 21))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 23))
+>z : Symbol(z, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 46))
+>Int : Symbol(Int, Decl(inferentialTypingObjectLiteralMethod1.ts, 0, 0))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 23))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 21))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod1.ts, 3, 21))
+
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
+>foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod1.ts, 2, 1))
+>method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 9))
+>p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
+>p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 46))
+>p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 54))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types
new file mode 100644
index 0000000000000..da2fa24060f7f
--- /dev/null
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.types
@@ -0,0 +1,43 @@
+=== tests/cases/compiler/inferentialTypingObjectLiteralMethod1.ts ===
+interface Int<T, U> {
+>Int : Int<T, U>
+>T : T
+>U : U
+
+    method(x: T): U;
+>method : (x: T) => U
+>x : T
+>T : T
+>U : U
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+>foo : <T, U>(x: T, y: Int<T, U>, z: Int<U, T>) => T
+>T : T
+>U : U
+>x : T
+>T : T
+>y : Int<T, U>
+>Int : Int<T, U>
+>T : T
+>U : U
+>z : Int<U, T>
+>Int : Int<T, U>
+>U : U
+>T : T
+>T : T
+
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
+>foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } }) : string
+>foo : <T, U>(x: T, y: Int<T, U>, z: Int<U, T>) => T
+>"" : string
+>{ method(p1) { return p1.length } } : { method(p1: string): number; }
+>method : (p1: string) => number
+>p1 : string
+>p1.length : number
+>p1 : string
+>length : number
+>{ method(p2) { return undefined } } : { method(p2: number): any; }
+>method : (p2: number) => any
+>p2 : number
+>undefined : undefined
+
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.js b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.js
new file mode 100644
index 0000000000000..fe53a619acd2e
--- /dev/null
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.js
@@ -0,0 +1,9 @@
+//// [inferentialTypingObjectLiteralMethod2.ts]
+interface Int<T, U> {
+    [s: string]: (x: T) => U;
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
+
+//// [inferentialTypingObjectLiteralMethod2.js]
+foo("", { method: function (p1) { return p1.length; } }, { method: function (p2) { return undefined; } });
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
new file mode 100644
index 0000000000000..fc8d39858b654
--- /dev/null
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
@@ -0,0 +1,39 @@
+=== tests/cases/compiler/inferentialTypingObjectLiteralMethod2.ts ===
+interface Int<T, U> {
+>Int : Symbol(Int, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 0))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 14))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 16))
+
+    [s: string]: (x: T) => U;
+>s : Symbol(s, Decl(inferentialTypingObjectLiteralMethod2.ts, 1, 5))
+>x : Symbol(x, Decl(inferentialTypingObjectLiteralMethod2.ts, 1, 18))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 14))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 16))
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+>foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod2.ts, 2, 1))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 21))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 23))
+>x : Symbol(x, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 27))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 21))
+>y : Symbol(y, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 32))
+>Int : Symbol(Int, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 0))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 21))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 23))
+>z : Symbol(z, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 46))
+>Int : Symbol(Int, Decl(inferentialTypingObjectLiteralMethod2.ts, 0, 0))
+>U : Symbol(U, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 23))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 21))
+>T : Symbol(T, Decl(inferentialTypingObjectLiteralMethod2.ts, 3, 21))
+
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
+>foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod2.ts, 2, 1))
+>method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 9))
+>p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
+>p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
+>length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 46))
+>p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 54))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types
new file mode 100644
index 0000000000000..be937410cef0f
--- /dev/null
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.types
@@ -0,0 +1,43 @@
+=== tests/cases/compiler/inferentialTypingObjectLiteralMethod2.ts ===
+interface Int<T, U> {
+>Int : Int<T, U>
+>T : T
+>U : U
+
+    [s: string]: (x: T) => U;
+>s : string
+>x : T
+>T : T
+>U : U
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+>foo : <T, U>(x: T, y: Int<T, U>, z: Int<U, T>) => T
+>T : T
+>U : U
+>x : T
+>T : T
+>y : Int<T, U>
+>Int : Int<T, U>
+>T : T
+>U : U
+>z : Int<U, T>
+>Int : Int<T, U>
+>U : U
+>T : T
+>T : T
+
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
+>foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } }) : string
+>foo : <T, U>(x: T, y: Int<T, U>, z: Int<U, T>) => T
+>"" : string
+>{ method(p1) { return p1.length } } : { [x: string]: (p1: string) => number; method(p1: string): number; }
+>method : (p1: string) => number
+>p1 : string
+>p1.length : number
+>p1 : string
+>length : number
+>{ method(p2) { return undefined } } : { [x: string]: (p2: number) => any; method(p2: number): any; }
+>method : (p2: number) => any
+>p2 : number
+>undefined : undefined
+
diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols
index 7b2a27b9992dd..715dd79c97a50 100644
--- a/tests/baselines/reference/iterableArrayPattern30.symbols
+++ b/tests/baselines/reference/iterableArrayPattern30.symbols
@@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11))
 >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18))
 >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21))
->Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1864, 1), Decl(lib.d.ts, 1886, 11))
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 615de521b83f7..9a6e2ef47ba9a 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -22,13 +22,13 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4774, 1), Decl(lib.d.ts, 4859, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4766, 1), Decl(lib.d.ts, 4851, 11))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4841, 39), Decl(lib.d.ts, 4848, 54))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4774, 1), Decl(lib.d.ts, 4859, 11))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4841, 39), Decl(lib.d.ts, 4848, 54))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4833, 39), Decl(lib.d.ts, 4840, 54))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4766, 1), Decl(lib.d.ts, 4851, 11))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4833, 39), Decl(lib.d.ts, 4840, 54))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -47,12 +47,12 @@ function f2(x: T1): T2 {
 
 var x3 = f1()
 >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3))
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
->f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158))
+>f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
@@ -62,7 +62,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 4771, 22), Decl(lib.d.ts, 4778, 158))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
index 7b28cf64ae942..e6eef0a184042 100644
--- a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
+++ b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
@@ -1,14 +1,11 @@
-tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(3,13): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts (2 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts (1 errors) ====
     function* gen() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
         // Once this is supported, the inner expression does not need to be parenthesized.
         var x = yield `abc${ x }def`;
-                ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt
deleted file mode 100644
index 46ca3c74b95f9..0000000000000
--- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts(3,20): error TS9000: 'yield' expressions are not currently supported.
-
-
-==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts (2 errors) ====
-    function* gen() {
-            ~
-!!! error TS9001: Generators are not currently supported.
-        // Once this is supported, yield *must* be parenthesized.
-        var x = `abc${ yield 10 }def`;
-                       ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.symbols
new file mode 100644
index 0000000000000..4248d66fb42e3
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.symbols
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts ===
+function* gen() {
+>gen : Symbol(gen, Decl(templateStringWithEmbeddedYieldKeywordES6.ts, 0, 0))
+
+    // Once this is supported, yield *must* be parenthesized.
+    var x = `abc${ yield 10 }def`;
+>x : Symbol(x, Decl(templateStringWithEmbeddedYieldKeywordES6.ts, 2, 7))
+}
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types
new file mode 100644
index 0000000000000..3a6f5d1672669
--- /dev/null
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts ===
+function* gen() {
+>gen : () => IterableIterator<number>
+
+    // Once this is supported, yield *must* be parenthesized.
+    var x = `abc${ yield 10 }def`;
+>x : string
+>`abc${ yield 10 }def` : string
+>yield 10 : any
+>10 : number
+}
+
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index c4015c3492d95..4ea9d0283a9ec 100644
--- a/tests/baselines/reference/typedArrays.symbols
+++ b/tests/baselines/reference/typedArrays.symbols
@@ -8,39 +8,39 @@ function CreateTypedArrayTypes() {
 
     typedArrays[0] = Int8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
@@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     return typedArrays;
@@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     return typedArrays;
@@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     return typedArrays;
@@ -242,65 +242,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     return typedArrays;
@@ -332,57 +332,57 @@ function CreateTypedArraysOf2() {
 
     typedArrays[0] = Int8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2386, 30))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2386, 30))
+>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2378, 30))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
+>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2378, 30))
 
     typedArrays[1] = Uint8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2676, 30))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2676, 30))
+>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2668, 30))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
+>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2668, 30))
 
     typedArrays[2] = Int16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3256, 30))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3256, 30))
+>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3248, 30))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
+>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3248, 30))
 
     typedArrays[3] = Uint16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3546, 30))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3546, 30))
+>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3538, 30))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
+>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3538, 30))
 
     typedArrays[4] = Int32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3836, 30))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3836, 30))
+>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3828, 30))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
+>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3828, 30))
 
     typedArrays[5] = Uint32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4126, 30))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4126, 30))
+>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4118, 30))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
+>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4118, 30))
 
     typedArrays[6] = Float32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4416, 30))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4416, 30))
+>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4408, 30))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
+>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4408, 30))
 
     typedArrays[7] = Float64Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4706, 30))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4706, 30))
+>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4698, 30))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
+>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4698, 30))
 
     typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2966, 30))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2966, 30))
+>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2958, 30))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
+>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2958, 30))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
@@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
@@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2104, 42), Decl(lib.d.ts, 2394, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2384, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2394, 44), Decl(lib.d.ts, 2684, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2674, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2974, 60), Decl(lib.d.ts, 3264, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3254, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3264, 46), Decl(lib.d.ts, 3554, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3544, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3554, 48), Decl(lib.d.ts, 3844, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3834, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3844, 46), Decl(lib.d.ts, 4134, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4124, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4134, 48), Decl(lib.d.ts, 4424, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4414, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4424, 50), Decl(lib.d.ts, 4714, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4704, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2684, 46), Decl(lib.d.ts, 2974, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2964, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
diff --git a/tests/baselines/reference/yieldExpression1.errors.txt b/tests/baselines/reference/yieldExpression1.errors.txt
index 91a379e617298..22bd6387b3f33 100644
--- a/tests/baselines/reference/yieldExpression1.errors.txt
+++ b/tests/baselines/reference/yieldExpression1.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/compiler/yieldExpression1.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/compiler/yieldExpression1.ts(2,5): error TS9000: 'yield' expressions are not currently supported.
+tests/cases/compiler/yieldExpression1.ts(1,9): error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
 
 
-==== tests/cases/compiler/yieldExpression1.ts (2 errors) ====
+==== tests/cases/compiler/yieldExpression1.ts (1 errors) ====
     function* foo() {
             ~
-!!! error TS9001: Generators are not currently supported.
+!!! error TS1219: Generators are only available when targeting ECMAScript 6 or higher.
         yield
-        ~~~~~
-!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/cases/compiler/inferentialTypingObjectLiteralMethod1.ts b/tests/cases/compiler/inferentialTypingObjectLiteralMethod1.ts
new file mode 100644
index 0000000000000..85b66f9219285
--- /dev/null
+++ b/tests/cases/compiler/inferentialTypingObjectLiteralMethod1.ts
@@ -0,0 +1,5 @@
+interface Int<T, U> {
+    method(x: T): U;
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
\ No newline at end of file
diff --git a/tests/cases/compiler/inferentialTypingObjectLiteralMethod2.ts b/tests/cases/compiler/inferentialTypingObjectLiteralMethod2.ts
new file mode 100644
index 0000000000000..dee3db70c2437
--- /dev/null
+++ b/tests/cases/compiler/inferentialTypingObjectLiteralMethod2.ts
@@ -0,0 +1,5 @@
+interface Int<T, U> {
+    [s: string]: (x: T) => U;
+}
+declare function foo<T, U>(x: T, y: Int<T, U>, z: Int<U, T>): T;
+foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } });
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts
new file mode 100644
index 0000000000000..d0b2a172433e8
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts
@@ -0,0 +1 @@
+yield * [];
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts
new file mode 100644
index 0000000000000..9a618df4bd085
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts
@@ -0,0 +1 @@
+yield *;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts
new file mode 100644
index 0000000000000..3384d609c1694
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts
@@ -0,0 +1,3 @@
+function *g() {
+    yield *;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts
new file mode 100644
index 0000000000000..4e652232e6a5b
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts
@@ -0,0 +1,3 @@
+function *g() {
+    yield * [];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext1.ts b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext1.ts
new file mode 100644
index 0000000000000..b4a3108fe34b7
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext1.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+declare class C {
+    *generator(): any;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext2.ts b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext2.ts
new file mode 100644
index 0000000000000..f4d560c521fcd
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext2.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+declare module M {
+    function *generator(): any;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext3.d.ts b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext3.d.ts
new file mode 100644
index 0000000000000..b4a3108fe34b7
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext3.d.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+declare class C {
+    *generator(): any;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext4.d.ts b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext4.d.ts
new file mode 100644
index 0000000000000..f4d560c521fcd
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext4.d.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+declare module M {
+    function *generator(): any;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext5.ts b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext5.ts
new file mode 100644
index 0000000000000..559b5e8dacb69
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext5.ts
@@ -0,0 +1,5 @@
+//@target: ES6
+//@declaration: true
+class C {
+    *generator(): any { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext6.ts b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext6.ts
new file mode 100644
index 0000000000000..fb7c358f189e2
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorInAmbientContext6.ts
@@ -0,0 +1,5 @@
+//@target: ES6
+//@declaration: true
+module M {
+    export function *generator(): any { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorOverloads1.ts b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads1.ts
new file mode 100644
index 0000000000000..c21ecea78268e
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads1.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+module M {
+    function* f(s: string): Iterable<any>;
+    function* f(s: number): Iterable<any>;
+    function* f(s: any): Iterable<any> { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts
new file mode 100644
index 0000000000000..de362aedc8b36
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads2.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+declare module M {
+    function* f(s: string): Iterable<any>;
+    function* f(s: number): Iterable<any>;
+    function* f(s: any): Iterable<any>;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorOverloads3.ts b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads3.ts
new file mode 100644
index 0000000000000..6f4825732410b
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads3.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+class C {
+    *f(s: string): Iterable<any>;
+    *f(s: number): Iterable<any>;
+    *f(s: any): Iterable<any> { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorOverloads4.ts b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads4.ts
new file mode 100644
index 0000000000000..7342a49a36604
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads4.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+class C {
+    f(s: string): Iterable<any>;
+    f(s: number): Iterable<any>;
+    *f(s: any): Iterable<any> { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorOverloads5.ts b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads5.ts
new file mode 100644
index 0000000000000..1efa9af0839de
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorOverloads5.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+module M {
+    function f(s: string): Iterable<any>;
+    function f(s: number): Iterable<any>;
+    function* f(s: any): Iterable<any> { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts
new file mode 100644
index 0000000000000..c01d7f5340f58
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g1(): Iterator<string> { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts
new file mode 100644
index 0000000000000..813ea07075da2
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g(): IterableIterator<any> {
+    return;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts
new file mode 100644
index 0000000000000..e77ec3d911c66
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g(): IterableIterator<number> {
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts
new file mode 100644
index 0000000000000..6f602a239819c
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g(): IterableIterator<number> {
+    return "";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts
new file mode 100644
index 0000000000000..a21d9e8ab63e7
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts
@@ -0,0 +1,5 @@
+//@target: ES6
+function* g(): IterableIterator<number> {
+    yield 0;
+    return "";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck14.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck14.ts
new file mode 100644
index 0000000000000..74761b147722c
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck14.ts
@@ -0,0 +1,5 @@
+//@target: ES6
+function* g() {
+    yield 0;
+    return "";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck15.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck15.ts
new file mode 100644
index 0000000000000..b810a13aa558f
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck15.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    return "";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck16.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck16.ts
new file mode 100644
index 0000000000000..06d3de394efdf
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck16.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    return;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck17.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck17.ts
new file mode 100644
index 0000000000000..15d760b794999
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck17.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield new Bar;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck18.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck18.ts
new file mode 100644
index 0000000000000..d63e69d1b8686
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck18.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Baz { z: number }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield new Baz;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck19.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck19.ts
new file mode 100644
index 0000000000000..e9b2cc29b2734
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck19.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield * [new Bar];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts
new file mode 100644
index 0000000000000..b66b3aab35639
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g1(): Iterable<string> { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck20.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck20.ts
new file mode 100644
index 0000000000000..5cb029205da5d
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck20.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Baz { z: number }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield * [new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck21.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck21.ts
new file mode 100644
index 0000000000000..991f082141efd
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck21.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+function* g(): IterableIterator<Foo> {
+    yield;
+    yield * new Bar;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck22.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck22.ts
new file mode 100644
index 0000000000000..0359ba3c4c9ce
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck22.ts
@@ -0,0 +1,11 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+function* g3() {
+    yield;
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck23.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck23.ts
new file mode 100644
index 0000000000000..20c98e9e7e7d0
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck23.ts
@@ -0,0 +1,12 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+function* g3() {
+    yield;
+    yield new Foo;
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck24.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck24.ts
new file mode 100644
index 0000000000000..9b383d8a02a56
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck24.ts
@@ -0,0 +1,12 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+function* g3() {
+    yield;
+    yield * [new Foo];
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts
new file mode 100644
index 0000000000000..9a942f174ae4c
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts
@@ -0,0 +1,11 @@
+//@target: ES6
+class Foo { x: number }
+class Bar extends Foo { y: string }
+class Baz { z: number }
+var g3: () => Iterable<Foo> = function* () {
+    yield;
+    yield new Bar;
+    yield new Baz;
+    yield *[new Bar];
+    yield *[new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts
new file mode 100644
index 0000000000000..334d21e38331c
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g(): IterableIterator<(x: string) => number> {
+    yield x => x.length;
+    yield *[x => x.length];
+    return x => x.length;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts
new file mode 100644
index 0000000000000..f501aa407f84d
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g(): IterableIterator<(x: string) => number> {
+    yield * function* () {
+        yield x => x.length;
+    } ();
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts
new file mode 100644
index 0000000000000..7a190e5bd45eb
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+function* g(): IterableIterator<(x: string) => number> {
+    yield * {
+        *[Symbol.iterator]() {
+            yield x => x.length;
+        }
+    };
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts
new file mode 100644
index 0000000000000..be99cf024417b
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+    yield function* () {
+        yield x => x.length;
+    } ()
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts
new file mode 100644
index 0000000000000..9b0e6f5ef59de
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g1(): IterableIterator<string> { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts
new file mode 100644
index 0000000000000..be99cf024417b
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g2(): Iterator<Iterable<(x: string) => number>> {
+    yield function* () {
+        yield x => x.length;
+    } ()
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts
new file mode 100644
index 0000000000000..f4082f7b46fa0
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g2(): Iterator<() => Iterable<(x: string) => number>> {
+    yield function* () {
+        yield x => x.length;
+    } ()
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck32.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck32.ts
new file mode 100644
index 0000000000000..f975eefa84125
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck32.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+var s: string;
+var f: () => number = () => yield s;
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck33.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck33.ts
new file mode 100644
index 0000000000000..4bb94263831f6
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck33.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+function* g() {
+    yield 0;
+    function* g2() {
+        yield "";
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck34.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck34.ts
new file mode 100644
index 0000000000000..3afd5617a0827
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck34.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+function* g() {
+    yield 0;
+    function* g2() {
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck35.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck35.ts
new file mode 100644
index 0000000000000..9adab4c0ed995
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck35.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+function* g() {
+    yield 0;
+    function g2() {
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck36.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck36.ts
new file mode 100644
index 0000000000000..e304dda48281a
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck36.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    yield yield 0;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck37.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck37.ts
new file mode 100644
index 0000000000000..f9fe46f4285b7
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck37.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    return yield yield 0;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck38.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck38.ts
new file mode 100644
index 0000000000000..03bb28ef0ec63
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck38.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+var yield;
+function* g() {
+    yield 0;
+    var v: typeof yield;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts
new file mode 100644
index 0000000000000..b578f8f2399b4
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts
@@ -0,0 +1,10 @@
+//@target: ES6
+function decorator(x: any) {
+    return y => { };
+}
+function* g() {
+    @decorator(yield 0)
+    class C {
+        x = yield 0;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck4.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck4.ts
new file mode 100644
index 0000000000000..160aee0d709cf
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck4.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g1(): {} { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts
new file mode 100644
index 0000000000000..2dee3dedf027d
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    class C extends (yield 0) { }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck41.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck41.ts
new file mode 100644
index 0000000000000..caa4eed0747a2
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck41.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g() {
+    let x = {
+        [yield 0]: 0
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck42.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck42.ts
new file mode 100644
index 0000000000000..4fe9ddced96c8
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck42.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+function* g() {
+    let x = {
+        [yield 0]() {
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck43.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck43.ts
new file mode 100644
index 0000000000000..e2b72f4b790cf
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck43.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+function* g() {
+    let x = {
+        *[yield 0]() {
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck44.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck44.ts
new file mode 100644
index 0000000000000..e7146fa6915fd
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck44.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+function* g() {
+    let x = {
+        get [yield 0]() {
+            return 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck45.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck45.ts
new file mode 100644
index 0000000000000..ce0822da4122f
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck45.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T): T;
+
+foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck46.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck46.ts
new file mode 100644
index 0000000000000..53c5c7131dbaa
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck46.ts
@@ -0,0 +1,10 @@
+//@target: ES6
+declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T): T;
+
+foo("", function* () {
+    yield* {
+        *[Symbol.iterator]() {
+            yield x => x.length
+        }
+    }
+}, p => undefined); // T is fixed, should be string
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts
new file mode 100644
index 0000000000000..6eb9fa74a6e83
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+//@noImplicitAny: true
+
+function* g() { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts
new file mode 100644
index 0000000000000..65885f28a5bd7
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+//@noImplicitAny: true
+
+function* g() {
+    yield;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts
new file mode 100644
index 0000000000000..956704d8a4ce1
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+//@noImplicitAny: true
+
+function* g() {
+    yield 0;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck5.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck5.ts
new file mode 100644
index 0000000000000..c1b659604bacb
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck5.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g1(): any { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts
new file mode 100644
index 0000000000000..1261d4b268bc6
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+//@noImplicitAny: true
+
+function* g() {
+    yield yield;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts
new file mode 100644
index 0000000000000..be88b9b99aa4e
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+//@noImplicitAny: true
+
+function* g() {
+    function* h() {
+        yield 0;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck52.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck52.ts
new file mode 100644
index 0000000000000..4e985dca92107
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck52.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Baz { z: number }
+function* g() {
+    yield new Foo;
+    yield new Baz;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck53.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck53.ts
new file mode 100644
index 0000000000000..9c75afe9ef177
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck53.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Baz { z: number }
+function* g() {
+    yield new Foo;
+    yield* [new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck54.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck54.ts
new file mode 100644
index 0000000000000..b5f47f76b3d50
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck54.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+class Foo { x: number }
+class Baz { z: number }
+function* g() {
+    yield* [new Foo];
+    yield* [new Baz];
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts
new file mode 100644
index 0000000000000..2041764a2f98e
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    var x = class C extends (yield) {};
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts
new file mode 100644
index 0000000000000..7aa66480a166c
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+function* g() {
+    var x = class C {
+        *[yield 0]() {
+            yield 0;
+        }
+    };
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts
new file mode 100644
index 0000000000000..f972a2a60e33f
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g() {
+    class C {
+        x = yield 0;
+    };
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts
new file mode 100644
index 0000000000000..081979be50587
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts
@@ -0,0 +1,6 @@
+//@target: ES6
+function* g() {
+    class C {
+        static x = yield 0;
+    };
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts
new file mode 100644
index 0000000000000..81aacecd7a30f
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts
@@ -0,0 +1,7 @@
+//@target: ES6
+function* g() {
+    class C {
+        @(yield "")
+        m() { }
+    };
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts
new file mode 100644
index 0000000000000..8f61f87db8307
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g1(): number { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts
new file mode 100644
index 0000000000000..36747936f1749
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts
@@ -0,0 +1,4 @@
+//@target: ES6
+function* g() {
+    class C extends (yield) {};
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts
new file mode 100644
index 0000000000000..31c36e2a626d3
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts
@@ -0,0 +1,5 @@
+//@target: ES6
+function * g() {
+    @(yield 0)
+    class C {};
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts
new file mode 100644
index 0000000000000..59e9b489d5f43
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts
@@ -0,0 +1,5 @@
+//@target: ES6
+interface WeirdIter extends IterableIterator<number> {
+    hello: string;
+}
+function* g1(): WeirdIter { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts
new file mode 100644
index 0000000000000..659406ee999fa
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts
@@ -0,0 +1,3 @@
+//@target: ES6
+interface BadGenerator extends Iterator<number>, Iterable<string> { }
+function* g3(): BadGenerator { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck9.ts b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck9.ts
new file mode 100644
index 0000000000000..f4386c70feba6
--- /dev/null
+++ b/tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck9.ts
@@ -0,0 +1,2 @@
+//@target: ES6
+function* g3(): void { }
\ No newline at end of file
diff --git a/tests/cases/fourslash/generatorDeclarationFormatting.ts b/tests/cases/fourslash/generatorDeclarationFormatting.ts
new file mode 100644
index 0000000000000..007380fd0dedf
--- /dev/null
+++ b/tests/cases/fourslash/generatorDeclarationFormatting.ts
@@ -0,0 +1,10 @@
+/// <reference path="fourslash.ts"/>
+
+//// function    *g() { }/*1*/
+//// var v = function    *() { };/*2*/
+
+format.document();
+goTo.marker('1');
+verify.currentLineContentIs("function* g() { }");
+goTo.marker('2');
+verify.currentLineContentIs("var v = function* () { };");
\ No newline at end of file
diff --git a/tests/cases/fourslash/yieldKeywordFormatting.ts b/tests/cases/fourslash/yieldKeywordFormatting.ts
new file mode 100644
index 0000000000000..8ea5d86673e5d
--- /dev/null
+++ b/tests/cases/fourslash/yieldKeywordFormatting.ts
@@ -0,0 +1,28 @@
+/// <reference path="fourslash.ts"/>
+
+////function* g3() {
+/////*1*/    yield   ;
+/////*2*/    g3().next(  yield   );
+/////*3*/    yield     new Bar;
+/////*4*/    yield   *      new Bar;
+/////*5*/    yield  *   [new Bar];
+/////*6*/    yield+ 1;
+/////*7*/    yield++ 1;
+////}
+
+format.document();
+let expected =
+    [
+        "    yield;",
+        "    g3().next(yield);",
+        "    yield new Bar;",
+        "    yield* new Bar;",
+        "    yield* [new Bar];",
+        "    yield + 1;", // Should be "yield +1". This case is covered by bug 3028.
+        "    yield ++1;"
+    ];
+
+for (let i = 0; i < expected.length; i++) {
+    goTo.marker("" + (i + 1));
+    verify.currentLineContentIs(expected[i]);
+}