diff --git a/package.json b/package.json
index ca137dcfb40..d6a8f538b78 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/binder.ts b/src/compiler/binder.ts
index b66497fc40d..82cfd59a5d6 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -519,17 +519,17 @@ module ts {
                     bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Class, SymbolFlags.ClassExcludes);
                     break;
                 case SyntaxKind.InterfaceDeclaration:
-                    bindDeclaration(<Declaration>node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes, /*isBlockScopeContainer*/ false);
+                    bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes);
                     break;
                 case SyntaxKind.TypeAliasDeclaration:
-                    bindDeclaration(<Declaration>node, SymbolFlags.TypeAlias, SymbolFlags.TypeAliasExcludes, /*isBlockScopeContainer*/ false);
+                    bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.TypeAlias, SymbolFlags.TypeAliasExcludes);
                     break;
                 case SyntaxKind.EnumDeclaration:
                     if (isConst(node)) {
-                        bindDeclaration(<Declaration>node, SymbolFlags.ConstEnum, SymbolFlags.ConstEnumExcludes, /*isBlockScopeContainer*/ false);
+                        bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.ConstEnum, SymbolFlags.ConstEnumExcludes);
                     }
                     else {
-                        bindDeclaration(<Declaration>node, SymbolFlags.RegularEnum, SymbolFlags.RegularEnumExcludes, /*isBlockScopeContainer*/ false);
+                        bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.RegularEnum, SymbolFlags.RegularEnumExcludes);
                     }
                     break;
                 case SyntaxKind.ModuleDeclaration:
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 528ee97602b..759b235ad0a 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;
@@ -338,7 +342,15 @@ module ts {
                 // Locals of a source file are not in scope (because they get merged into the global symbol table)
                 if (location.locals && !isGlobalSourceFile(location)) {
                     if (result = getSymbol(location.locals, name, meaning)) {
-                        break loop;
+                        // Type parameters of a function are in scope in the entire function declaration, including the parameter
+                        // list and return type. However, local types are only in scope in the function body.
+                        if (!(meaning & SymbolFlags.Type) ||
+                            !(result.flags & (SymbolFlags.Type & ~SymbolFlags.TypeParameter)) ||
+                            !isFunctionLike(location) ||
+                            lastLocation === (<FunctionLikeDeclaration>location).body) {
+                            break loop;
+                        }
+                        result = undefined;
                     }
                 }
                 switch (location.kind) {
@@ -1522,17 +1534,55 @@ module ts {
                     }
                 }
 
+                function writeSymbolTypeReference(symbol: Symbol, typeArguments: Type[], pos: number, end: number) {
+                    // Unnamed function expressions, arrow functions, and unnamed class expressions have reserved names that
+                    // we don't want to display
+                    if (!isReservedMemberName(symbol.name)) {
+                        buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type);
+                    }
+                    if (pos < end) {
+                        writePunctuation(writer, SyntaxKind.LessThanToken);
+                        writeType(typeArguments[pos++], TypeFormatFlags.None);
+                        while (pos < end) {
+                            writePunctuation(writer, SyntaxKind.CommaToken);
+                            writeSpace(writer);
+                            writeType(typeArguments[pos++], TypeFormatFlags.None);
+                        }
+                        writePunctuation(writer, SyntaxKind.GreaterThanToken);
+                    }
+                }
+
                 function writeTypeReference(type: TypeReference, flags: TypeFormatFlags) {
+                    let typeArguments = type.typeArguments;
                     if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
-                        writeType(type.typeArguments[0], TypeFormatFlags.InElementType);
+                        writeType(typeArguments[0], TypeFormatFlags.InElementType);
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
                     else {
-                        buildSymbolDisplay(type.target.symbol, writer, enclosingDeclaration, SymbolFlags.Type);
-                        writePunctuation(writer, SyntaxKind.LessThanToken);
-                        writeTypeList(type.typeArguments, /*union*/ false);
-                        writePunctuation(writer, SyntaxKind.GreaterThanToken);
+                        // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
+                        // for outer type parameters, and f and g are the respective declaring containers of those
+                        // type parameters.
+                        let outerTypeParameters = type.target.outerTypeParameters;
+                        let i = 0;
+                        if (outerTypeParameters) {
+                            let length = outerTypeParameters.length;
+                            while (i < length) {
+                                // Find group of type arguments for type parameters with the same declaring container.
+                                let start = i;
+                                let parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
+                                do {
+                                    i++;
+                                } while (i < length && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
+                                // When type parameters are their own type arguments for the whole group (i.e. we have
+                                // the default outer type arguments), we don't show the group.
+                                if (!rangeEquals(outerTypeParameters, typeArguments, start, i)) {
+                                    writeSymbolTypeReference(parent, typeArguments, start, i);
+                                    writePunctuation(writer, SyntaxKind.DotToken);
+                                }
+                            }
+                        }
+                        writeSymbolTypeReference(type.symbol, typeArguments, i, typeArguments.length);
                     }
                 }
 
@@ -1728,7 +1778,7 @@ module ts {
             function buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) {
                 let targetSymbol = getTargetSymbol(symbol);
                 if (targetSymbol.flags & SymbolFlags.Class || targetSymbol.flags & SymbolFlags.Interface) {
-                    buildDisplayForTypeParametersAndDelimiters(getTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags);
+                    buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags);
                 }
             }
 
@@ -2150,7 +2200,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)) {
@@ -2465,30 +2515,68 @@ module ts {
             }
         }
 
-        // Return combined list of type parameters from all declarations of a class or interface. Elsewhere we check they're all
-        // the same, but even if they're not we still need the complete list to ensure instantiations supply type arguments
-        // for all type parameters.
-        function getTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] {
-            let result: TypeParameter[];
-            forEach(symbol.declarations, node => {
-                if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration) {
-                    let declaration = <InterfaceDeclaration>node;
-                    if (declaration.typeParameters && declaration.typeParameters.length) {
-                        forEach(declaration.typeParameters, node => {
-                            let tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
-                            if (!result) {
-                                result = [tp];
-                            }
-                            else if (!contains(result, tp)) {
-                                result.push(tp);
-                            }
-                        });
+        // Appends the type parameters given by a list of declarations to a set of type parameters and returns the resulting set.
+        // The function allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set
+        // in-place and returns the same array.
+        function appendTypeParameters(typeParameters: TypeParameter[], declarations: TypeParameterDeclaration[]): TypeParameter[] {
+            for (let declaration of declarations) {
+                let tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
+                if (!typeParameters) {
+                    typeParameters = [tp];
+                }
+                else if (!contains(typeParameters, tp)) {
+                    typeParameters.push(tp);
+                }
+            }
+            return typeParameters;
+        }
+
+        // Appends the outer type parameters of a node to a set of type parameters and returns the resulting set. The function
+        // allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set in-place and
+        // returns the same array.
+        function appendOuterTypeParameters(typeParameters: TypeParameter[], node: Node): TypeParameter[]{
+            while (true) {
+                node = node.parent;
+                if (!node) {
+                    return typeParameters;
+                }
+                if (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.FunctionDeclaration ||
+                    node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.MethodDeclaration ||
+                    node.kind === SyntaxKind.ArrowFunction) {
+                    let declarations = (<ClassDeclaration | FunctionLikeDeclaration>node).typeParameters;
+                    if (declarations) {
+                        return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations);
                     }
                 }
-            });
+            }
+        }
+
+        // The outer type parameters are those defined by enclosing generic classes, methods, or functions.
+        function getOuterTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] {
+            var kind = symbol.flags & SymbolFlags.Class ? SyntaxKind.ClassDeclaration : SyntaxKind.InterfaceDeclaration;
+            return appendOuterTypeParameters(undefined, getDeclarationOfKind(symbol, kind));
+        }
+
+        // The local type parameters are the combined set of type parameters from all declarations of the class or interface.
+        function getLocalTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] {
+            let result: TypeParameter[];
+            for (let node of symbol.declarations) {
+                if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration) {
+                    let declaration = <InterfaceDeclaration>node;
+                    if (declaration.typeParameters) {
+                        result = appendTypeParameters(result, declaration.typeParameters);
+                    }
+                }
+            }
             return result;
         }
 
+        // The full set of type parameters for a generic class or interface type consists of its outer type parameters plus
+        // its locally declared type parameters.
+        function getTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] {
+            return concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterface(symbol));
+        }
+
         function getBaseTypes(type: InterfaceType): ObjectType[] {
             let typeWithBaseTypes = <InterfaceTypeWithBaseTypes>type;
             if (!typeWithBaseTypes.baseTypes) {
@@ -2558,10 +2646,13 @@ module ts {
             if (!links.declaredType) {
                 let kind = symbol.flags & SymbolFlags.Class ? TypeFlags.Class : TypeFlags.Interface;
                 let type = links.declaredType = <InterfaceType>createObjectType(kind, symbol);
-                let typeParameters = getTypeParametersOfClassOrInterface(symbol);
-                if (typeParameters) {
+                let outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
+                let localTypeParameters = getLocalTypeParametersOfClassOrInterface(symbol);
+                if (outerTypeParameters || localTypeParameters) {
                     type.flags |= TypeFlags.Reference;
-                    type.typeParameters = typeParameters;
+                    type.typeParameters = concatenate(outerTypeParameters, localTypeParameters);
+                    type.outerTypeParameters = outerTypeParameters;
+                    type.localTypeParameters = localTypeParameters;
                     (<GenericType>type).instantiations = {};
                     (<GenericType>type).instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
                     (<GenericType>type).target = <GenericType>type;
@@ -2751,12 +2842,12 @@ module ts {
                 return map(baseSignatures, baseSignature => {
                     let signature = baseType.flags & TypeFlags.Reference ?
                         getSignatureInstantiation(baseSignature, (<TypeReference>baseType).typeArguments) : cloneSignature(baseSignature);
-                    signature.typeParameters = classType.typeParameters;
+                    signature.typeParameters = classType.localTypeParameters;
                     signature.resolvedReturnType = classType;
                     return signature;
                 });
             }
-            return [createSignature(undefined, classType.typeParameters, emptyArray, classType, 0, false, false)];
+            return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, 0, false, false)];
         }
 
         function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
@@ -3105,7 +3196,7 @@ module ts {
             let links = getNodeLinks(declaration);
             if (!links.resolvedSignature) {
                 let classType = declaration.kind === SyntaxKind.Constructor ? getDeclaredTypeOfClassOrInterface((<ClassDeclaration>declaration.parent).symbol) : undefined;
-                let typeParameters = classType ? classType.typeParameters :
+                let typeParameters = classType ? classType.localTypeParameters :
                     declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined;
                 let parameters: Symbol[] = [];
                 let hasStringLiterals = false;
@@ -3307,6 +3398,10 @@ module ts {
             return type.constraint === noConstraintType ? undefined : type.constraint;
         }
 
+        function getParentSymbolOfTypeParameter(typeParameter: TypeParameter): Symbol {
+            return getSymbolOfNode(getDeclarationOfKind(typeParameter.symbol, SyntaxKind.TypeParameter).parent);
+        }
+
         function getTypeListId(types: Type[]) {
             switch (types.length) {
                 case 1:
@@ -3422,12 +3517,22 @@ module ts {
                         else {
                             type = getDeclaredTypeOfSymbol(symbol);
                             if (type.flags & (TypeFlags.Class | TypeFlags.Interface) && type.flags & TypeFlags.Reference) {
-                                let typeParameters = (<InterfaceType>type).typeParameters;
-                                if (node.typeArguments && node.typeArguments.length === typeParameters.length) {
-                                    type = createTypeReference(<GenericType>type, map(node.typeArguments, getTypeFromTypeNode));
+                                // In a type reference, the outer type parameters of the referenced class or interface are automatically
+                                // supplied as type arguments and the type reference only specifies arguments for the local type parameters
+                                // of the class or interface.
+                                let localTypeParameters = (<InterfaceType>type).localTypeParameters;
+                                let expectedTypeArgCount = localTypeParameters ? localTypeParameters.length : 0;
+                                let typeArgCount = node.typeArguments ? node.typeArguments.length : 0;
+                                if (typeArgCount === expectedTypeArgCount) {
+                                    // When no type arguments are expected we already have the right type because all outer type parameters
+                                    // have themselves as default type arguments.
+                                    if (typeArgCount) {
+                                        type = createTypeReference(<GenericType>type, concatenate((<InterfaceType>type).outerTypeParameters,
+                                            map(node.typeArguments, getTypeFromTypeNode)));
+                                    }
                                 }
                                 else {
-                                    error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length);
+                                    error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), expectedTypeArgCount);
                                     type = undefined;
                                 }
                             }
@@ -3473,16 +3578,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 +3612,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 {
@@ -3897,7 +4009,7 @@ module ts {
                     return mapper(<TypeParameter>type);
                 }
                 if (type.flags & TypeFlags.Anonymous) {
-                    return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) ?
+                    return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) ?
                         instantiateAnonymousType(<ObjectType>type, mapper) : type;
                 }
                 if (type.flags & TypeFlags.Reference) {
@@ -5784,20 +5896,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 +6071,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 +6103,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 +6144,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 +6262,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 +7456,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;
+                    }
                 }
-                // 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.
+                else {
+                    types = checkAndAggregateReturnExpressionTypes(<Block>func.body, contextualMapper);
+                    if (types.length === 0) {
+                        return voidType;
+                    }
+                }
+
+                // 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 +7500,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 +8164,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 +8405,7 @@ module ts {
                 case SyntaxKind.OmittedExpression:
                     return undefinedType;
                 case SyntaxKind.YieldExpression:
-                    checkYieldExpression(<YieldExpression>node);
-                    return unknownType;
+                    return checkYieldExpression(<YieldExpression>node);
             }
             return unknownType;
         }
@@ -8229,6 +8458,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 +8500,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);
@@ -8981,7 +9241,6 @@ module ts {
         function checkFunctionDeclaration(node: FunctionDeclaration): void {
             if (produceDiagnostics) {
                 checkFunctionLikeDeclaration(node) ||
-                checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) ||
                 checkGrammarFunctionName(node.name) ||
                 checkGrammarForGenerator(node);
 
@@ -9032,10 +9291,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));
+                }
             }
         }
 
@@ -9343,7 +9611,7 @@ module ts {
 
         function checkVariableStatement(node: VariableStatement) {
             // Grammar checking
-            checkGrammarDecorators(node) || checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) || checkGrammarModifiers(node) || checkGrammarVariableDeclarationList(node.declarationList) || checkGrammarForDisallowedLetOrConstStatement(node);
+            checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarVariableDeclarationList(node.declarationList) || checkGrammarForDisallowedLetOrConstStatement(node);
 
             forEach(node.declarationList.declarations, checkSourceElement);
         }
@@ -9450,7 +9718,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 +9794,7 @@ module ts {
             }
 
             if (languageVersion >= ScriptTarget.ES6) {
-                return checkIteratedType(inputType, errorNode) || anyType;
+                return checkElementTypeOfIterable(inputType, errorNode);
             }
 
             if (allowStringInput) {
@@ -9547,100 +9815,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];
+                if ((type.flags & TypeFlags.Reference) && (<GenericType>type).target === globalIterableType) {
+                    typeAsIterable.iterableElementType = (<GenericType>type).typeArguments[0];
                 }
-
-                let iteratorFunction = getTypeOfPropertyOfType(iterable, getPropertyNameForKnownSymbolName("iterator"));
-                if (iteratorFunction && allConstituentTypesHaveKind(iteratorFunction, 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);
+                else {
+                    let iteratorFunction = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator"));
+                    if (iteratorFunction && iteratorFunction.flags & TypeFlags.Any) {
+                        return undefined;
                     }
-                    return undefined;
-                }
 
-                let iterator = getUnionType(map(iteratorFunctionSignatures, getReturnTypeOfSignature));
-                if (allConstituentTypesHaveKind(iterator, TypeFlags.Any)) {
-                    return undefined;
-                }
-
-                let iteratorNextFunction = getTypeOfPropertyOfType(iterator, "next");
-                if (iteratorNextFunction && allConstituentTypesHaveKind(iteratorNextFunction, 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 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 iteratorNextResult = getUnionType(map(iteratorNextFunctionSignatures, getReturnTypeOfSignature));
-                if (allConstituentTypesHaveKind(iteratorNextResult, TypeFlags.Any)) {
-                    return undefined;
+                    typeAsIterable.iterableElementType = getElementTypeOfIterator(getUnionType(map(iteratorFunctionSignatures, getReturnTypeOfSignature)), errorNode);
                 }
-
-                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 iteratorNextValue;
             }
+
+            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);
+                        }
+                        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);
+                        }
+                        return undefined;
+                    }
+
+                    typeAsIterator.iteratorElementType = iteratorNextValue;
+                }
+            }
+
+            return typeAsIterator.iteratorElementType;
+        }
+
+        function getElementTypeOfIterableIterator(type: Type): Type {
+            if (type.flags & TypeFlags.Any) {
+                return undefined;
+            }
+
+            // 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 +10045,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);
+                    }
                 }
             }
         }
@@ -10005,10 +10323,6 @@ module ts {
         function checkClassDeclaration(node: ClassDeclaration) {
             checkGrammarDeclarationNameInStrictMode(node);
             // Grammar checking
-            if (node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) {
-                grammarErrorOnNode(node, Diagnostics.class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration);
-            }
-
             if (!node.name && !(node.flags & NodeFlags.Default)) {
                 grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
             }
@@ -11227,93 +11541,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 +12275,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 +12293,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 +12305,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);
@@ -12260,19 +12491,28 @@ module ts {
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.MethodSignature:
                 case SyntaxKind.IndexSignature:
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.InterfaceDeclaration:
                 case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.EnumDeclaration:
-                case SyntaxKind.VariableStatement:
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.TypeAliasDeclaration:
                 case SyntaxKind.ImportDeclaration:
                 case SyntaxKind.ImportEqualsDeclaration:
                 case SyntaxKind.ExportDeclaration:
                 case SyntaxKind.ExportAssignment:
                 case SyntaxKind.Parameter:
                     break;
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.VariableStatement:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.TypeAliasDeclaration:
+                    if (node.modifiers && node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) {
+                        return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here);
+                    }
+                    break;
+                case SyntaxKind.EnumDeclaration:
+                    if (node.modifiers && (node.modifiers.length > 1 || node.modifiers[0].kind !== SyntaxKind.ConstKeyword) &&
+                        node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) {
+                        return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here);
+                    }
+                    break;
                 default:
                     return false;
             }
@@ -12624,7 +12864,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/core.ts b/src/compiler/core.ts
index f5719033a2a..281bfa36ece 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -129,6 +129,16 @@ module ts {
         }
     } 
 
+    export function rangeEquals<T>(array1: T[], array2: T[], pos: number, end: number) {
+        while (pos < end) {
+            if (array1[pos] !== array2[pos]) {
+                return false;
+            }
+            pos++;
+        }
+        return true;
+    }
+
     /**
      * Returns the last element of an array if non-empty, undefined otherwise.
      */
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index 61a55dde55a..6e73d28bddd 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,7 +174,10 @@ 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'." },
-        _0_tag_already_specified: { code: 1219, category: DiagnosticCategory.Error, key: "'{0}' tag already specified." },
+        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: 1222, 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." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
@@ -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,10 +546,7 @@ 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." },
     };
 }
\ No newline at end of file
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index a4d7e3168d7..d5764605d51 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,11 +682,25 @@
     "Export assignment is not supported when '--module' flag is 'system'.": {
         "category": "Error",
         "code": 1218
-    },
-    "'{0}' tag already specified.": {
+    },    
+    "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": 1222
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -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
@@ -2167,9 +2185,5 @@
     "'class' expressions are not currently supported.": {
         "category": "Error",
         "code": 9003
-    },
-    "'class' declarations are only supported directly inside a module or as a top level declaration.": {
-        "category": "Error",
-        "code": 9004
     }
 }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 28fd8184d7e..4a46e375f87 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -401,7 +401,7 @@ module ts {
     module Parser {
         // Share a single scanner across all calls to parse a source file.  This helps speed things
         // up by avoiding the cost of creating/compiling scanners over and over again.
-        const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia:*/ true);
+        const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
         const disallowInAndDecoratorContext = ParserContextFlags.DisallowIn | ParserContextFlags.Decorator;
 
         let sourceFile: SourceFile;
@@ -493,6 +493,13 @@ module ts {
         // attached to the EOF token.
         let parseErrorBeforeNextFinishedNode: boolean = false;
 
+        export const enum StatementFlags {
+            None = 0,
+            Statement = 1,
+            ModuleElement = 2,
+            StatementOrModuleElement = Statement | ModuleElement
+        }
+
         export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean): SourceFile {
             initializeState(fileName, _sourceText, languageVersion, _syntaxCursor);
 
@@ -847,7 +854,7 @@ module ts {
         // was in immediately prior to invoking the callback.  The result of invoking the callback
         // is returned from this function.
         function lookAhead<T>(callback: () => T): T {
-            return speculationHelper(callback, /*isLookAhead:*/ true);
+            return speculationHelper(callback, /*isLookAhead*/ true);
         }
 
         // Invokes the provided callback.  If the callback returns something falsy, then it restores
@@ -855,7 +862,7 @@ module ts {
         // callback returns something truthy, then the parser state is not rolled back.  The result
         // of invoking the callback is returned from this function.
         function tryParse<T>(callback: () => T): T {
-            return speculationHelper(callback, /*isLookAhead:*/ false);
+            return speculationHelper(callback, /*isLookAhead*/ false);
         }
 
         // Ignore strict mode flag because we will report an error in type checker instead.
@@ -1004,7 +1011,7 @@ module ts {
                 return finishNode(node);
             }
 
-            return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition:*/ false, diagnosticMessage || Diagnostics.Identifier_expected);
+            return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition*/ false, diagnosticMessage || Diagnostics.Identifier_expected);
         }
 
         function parseIdentifier(diagnosticMessage?: DiagnosticMessage): Identifier {
@@ -1023,7 +1030,7 @@ module ts {
 
         function parsePropertyNameWorker(allowComputedPropertyNames: boolean): DeclarationName {
             if (token === SyntaxKind.StringLiteral || token === SyntaxKind.NumericLiteral) {
-                return parseLiteralNode(/*internName:*/ true);
+                return parseLiteralNode(/*internName*/ true);
             }
             if (allowComputedPropertyNames && token === SyntaxKind.OpenBracketToken) {
                 return parseComputedPropertyName();
@@ -1121,10 +1128,17 @@ module ts {
             switch (parsingContext) {
                 case ParsingContext.SourceElements:
                 case ParsingContext.ModuleElements:
-                    return isSourceElement(inErrorRecovery);
+                    // If we're in error recovery, then we don't want to treat ';' as an empty statement.
+                    // The problem is that ';' can show up in far too many contexts, and if we see one
+                    // and assume it's a statement, then we may bail out inappropriately from whatever
+                    // we're parsing.  For example, if we have a semicolon in the middle of a class, then
+                    // we really don't want to assume the class is over and we're on a statement in the
+                    // outer module.  We just want to consume and move on.
+                    return !(token === SyntaxKind.SemicolonToken && inErrorRecovery) && isStartOfModuleElement();
                 case ParsingContext.BlockStatements:
                 case ParsingContext.SwitchClauseStatements:
-                    return isStartOfStatement(inErrorRecovery);
+                    // During error recovery we don't treat empty statements as statements
+                    return !(token === SyntaxKind.SemicolonToken && inErrorRecovery) && isStartOfStatement();
                 case ParsingContext.SwitchClauses:
                     return token === SyntaxKind.CaseKeyword || token === SyntaxKind.DefaultKeyword;
                 case ParsingContext.TypeMembers:
@@ -1805,7 +1819,7 @@ module ts {
                     // Report that we need an identifier.  However, report it right after the dot,
                     // and not on the next token.  This is because the next token might actually
                     // be an identifier and the error woudl be quite confusing.
-                    return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentToken:*/ true, Diagnostics.Identifier_expected);
+                    return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentToken*/ true, Diagnostics.Identifier_expected);
                 }
             }
 
@@ -1843,7 +1857,7 @@ module ts {
                 literal = parseLiteralNode();
             }
             else {
-                literal = <LiteralExpression>parseExpectedToken(SyntaxKind.TemplateTail, /*reportAtCurrentPosition:*/ false, Diagnostics._0_expected, tokenToString(SyntaxKind.CloseBraceToken));
+                literal = <LiteralExpression>parseExpectedToken(SyntaxKind.TemplateTail, /*reportAtCurrentPosition*/ false, Diagnostics._0_expected, tokenToString(SyntaxKind.CloseBraceToken));
             }
 
             span.literal = literal;
@@ -1936,7 +1950,7 @@ module ts {
         function parseParameterType(): TypeNode {
             if (parseOptional(SyntaxKind.ColonToken)) {
                 return token === SyntaxKind.StringLiteral
-                    ? <StringLiteral>parseLiteralNode(/*internName:*/ true)
+                    ? <StringLiteral>parseLiteralNode(/*internName*/ true)
                     : parseType();
             }
 
@@ -2077,7 +2091,7 @@ module ts {
             if (kind === SyntaxKind.ConstructSignature) {
                 parseExpected(SyntaxKind.NewKeyword);
             }
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*requireCompleteParameterList*/ false, node);
             parseTypeMemberSemicolon();
             return finishNode(node);
         }
@@ -2167,7 +2181,7 @@ module ts {
 
                 // Method signatues don't exist in expression contexts.  So they have neither
                 // [Yield] nor [GeneratorParameter]
-                fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, method);
+                fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*requireCompleteParameterList*/ false, method);
                 parseTypeMemberSemicolon();
                 return finishNode(method);
             }
@@ -2224,7 +2238,7 @@ module ts {
                 case SyntaxKind.OpenBracketToken:
                     // Indexer or computed property
                     return isIndexSignature()
-                        ? parseIndexSignatureDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined)
+                        ? parseIndexSignatureDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined)
                         : parsePropertyOrMethodSignature();
                 case SyntaxKind.NewKeyword:
                     if (lookAhead(isStartOfConstructSignature)) {
@@ -2306,7 +2320,7 @@ module ts {
             if (kind === SyntaxKind.ConstructorType) {
                 parseExpected(SyntaxKind.NewKeyword);
             }
-            fillSignature(SyntaxKind.EqualsGreaterThanToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node);
+            fillSignature(SyntaxKind.EqualsGreaterThanToken, /*yieldAndGeneratorParameterContext*/ false, /*requireCompleteParameterList*/ false, node);
             return finishNode(node);
         }
 
@@ -2615,7 +2629,7 @@ module ts {
             // Otherwise, we try to parse out the conditional expression bit.  We want to allow any
             // binary expression here, so we pass in the 'lowest' precedence here so that it matches
             // and consumes anything.
-            let expr = parseBinaryExpressionOrHigher(/*precedence:*/ 0);
+            let expr = parseBinaryExpressionOrHigher(/*precedence*/ 0);
 
             // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
@@ -2677,12 +2691,6 @@ module ts {
             return !scanner.hasPrecedingLineBreak() && isIdentifier()
         }
 
-        function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() {
-            nextToken();
-            return !scanner.hasPrecedingLineBreak() &&
-                (isIdentifier() || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.OpenBracketToken);
-        }
-
         function parseYieldExpression(): YieldExpression {
             let node = <YieldExpression>createNode(SyntaxKind.YieldExpression);
 
@@ -2737,7 +2745,7 @@ module ts {
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             let arrowFunction = triState === Tristate.True
-                ? parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity:*/ true)
+                ? parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity*/ true)
                 : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead);
 
             if (!arrowFunction) {
@@ -2748,7 +2756,7 @@ module ts {
             // If we have an arrow, then try to parse the body. Even if not, try to parse if we
             // have an opening brace, just in case we're in an error state.
             var lastToken = token;
-            arrowFunction.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition:*/false, Diagnostics._0_expected, "=>");
+            arrowFunction.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition*/false, Diagnostics._0_expected, "=>");
             arrowFunction.body = (lastToken === SyntaxKind.EqualsGreaterThanToken || lastToken === SyntaxKind.OpenBraceToken)
                 ? parseArrowFunctionExpressionBody()
                 : parseIdentifier();
@@ -2846,7 +2854,7 @@ module ts {
         }
 
         function parsePossibleParenthesizedArrowFunctionExpressionHead(): ArrowFunction {
-            return parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity:*/ false);
+            return parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity*/ false);
         }
 
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction {
@@ -2858,7 +2866,7 @@ module ts {
             // a => (b => c)
             // And think that "(b =>" was actually a parenthesized arrow function with a missing
             // close paren.
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ !allowAmbiguity, node);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*requireCompleteParameterList*/ !allowAmbiguity, node);
 
             // If we couldn't get parameters, we definitely could not parse out an arrow function.
             if (!node.parameters) {
@@ -2883,14 +2891,14 @@ module ts {
 
         function parseArrowFunctionExpressionBody(): Block | Expression {
             if (token === SyntaxKind.OpenBraceToken) {
-                return parseFunctionBlock(/*allowYield:*/ false, /* ignoreMissingOpenBrace */ false);
+                return parseFunctionBlock(/*allowYield*/ false, /*ignoreMissingOpenBrace*/ false);
             }
 
-            if (isStartOfStatement(/*inErrorRecovery:*/ true) &&
-                !isStartOfExpressionStatement() &&
+            if (token !== SyntaxKind.SemicolonToken &&
                 token !== SyntaxKind.FunctionKeyword &&
-                token !== SyntaxKind.ClassKeyword) {
-
+                token !== SyntaxKind.ClassKeyword &&
+                isStartOfStatement() &&
+                !isStartOfExpressionStatement()) {
                 // Check if we got a plain statement (i.e. no expression-statements, no function/class expressions/declarations)
                 //
                 // Here we try to recover from a potential error situation in the case where the
@@ -2905,7 +2913,7 @@ module ts {
                 // up preemptively closing the containing construct.
                 //
                 // Note: even when 'ignoreMissingOpenBrace' is passed as true, parseBody will still error.
-                return parseFunctionBlock(/*allowYield:*/ false, /* ignoreMissingOpenBrace */ true);
+                return parseFunctionBlock(/*allowYield*/ false, /*ignoreMissingOpenBrace*/ true);
             }
 
             return parseAssignmentExpressionOrHigher();
@@ -2924,7 +2932,7 @@ module ts {
             node.condition = leftOperand;
             node.questionToken = questionToken;
             node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher);
-            node.colonToken = parseExpectedToken(SyntaxKind.ColonToken, /*reportAtCurrentPosition:*/ false,
+            node.colonToken = parseExpectedToken(SyntaxKind.ColonToken, /*reportAtCurrentPosition*/ false,
                 Diagnostics._0_expected, tokenToString(SyntaxKind.ColonToken));
             node.whenFalse = parseAssignmentExpressionOrHigher();
             return finishNode(node);
@@ -3188,8 +3196,8 @@ module ts {
             // If it wasn't then just try to parse out a '.' and report an error.
             let node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
             node.expression = expression;
-            node.dotToken = parseExpectedToken(SyntaxKind.DotToken, /*reportAtCurrentPosition:*/ false, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
-            node.name = parseRightSideOfDot(/*allowIdentifierNames:*/ true);
+            node.dotToken = parseExpectedToken(SyntaxKind.DotToken, /*reportAtCurrentPosition*/ false, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
+            node.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
             return finishNode(node);
         }
 
@@ -3209,7 +3217,7 @@ module ts {
                     let propertyAccess = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
                     propertyAccess.expression = expression;
                     propertyAccess.dotToken = dotToken;
-                    propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames:*/ true);
+                    propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
                     expression = finishNode(propertyAccess);
                     continue;
                 }
@@ -3472,7 +3480,7 @@ module ts {
                 node.flags |= NodeFlags.MultiLine;
             }
 
-            node.properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralElement, /*considerSemicolonAsDelimeter:*/ true);
+            node.properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralElement, /*considerSemicolonAsDelimeter*/ true);
             parseExpected(SyntaxKind.CloseBraceToken);
             return finishNode(node);
         }
@@ -3490,8 +3498,8 @@ module ts {
             parseExpected(SyntaxKind.FunctionKeyword);
             node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
             node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier();
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ !!node.asteriskToken, /*requireCompleteParameterList:*/ false, node);
-            node.body = parseFunctionBlock(/*allowYield:*/ !!node.asteriskToken, /* ignoreMissingOpenBrace */ false);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ !!node.asteriskToken, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlock(/*allowYield*/ !!node.asteriskToken, /* ignoreMissingOpenBrace */ false);
             if (saveDecoratorContext) {
                 setDecoratorContext(true);
             }
@@ -3601,7 +3609,7 @@ module ts {
             let initializer: VariableDeclarationList | Expression = undefined;
             if (token !== SyntaxKind.SemicolonToken) {
                 if (token === SyntaxKind.VarKeyword || token === SyntaxKind.LetKeyword || token === SyntaxKind.ConstKeyword) {
-                    initializer = parseVariableDeclarationList(/*inForStatementInitializer:*/ true);
+                    initializer = parseVariableDeclarationList(/*inForStatementInitializer*/ true);
                 }
                 else {
                     initializer = disallowInAnd(parseExpression);
@@ -3731,14 +3739,14 @@ module ts {
             let node = <TryStatement>createNode(SyntaxKind.TryStatement);
 
             parseExpected(SyntaxKind.TryKeyword);
-            node.tryBlock = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode*/ false);
+            node.tryBlock = parseBlock(/*ignoreMissingOpenBrace*/ false, /*checkForStrictMode*/ false);
             node.catchClause = token === SyntaxKind.CatchKeyword ? parseCatchClause() : undefined;
 
             // If we don't have a catch clause, then we must have a finally clause.  Try to parse
             // one out no matter what.
             if (!node.catchClause || token === SyntaxKind.FinallyKeyword) {
                 parseExpected(SyntaxKind.FinallyKeyword);
-                node.finallyBlock = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode*/ false);
+                node.finallyBlock = parseBlock(/*ignoreMissingOpenBrace*/ false, /*checkForStrictMode*/ false);
             }
 
             return finishNode(node);
@@ -3752,7 +3760,7 @@ module ts {
             }
 
             parseExpected(SyntaxKind.CloseParenToken);
-            result.block = parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode:*/ false);
+            result.block = parseBlock(/*ignoreMissingOpenBrace*/ false, /*checkForStrictMode*/ false);
             return finishNode(result);
         }
 
@@ -3784,34 +3792,72 @@ module ts {
             }
         }
 
-        function isStartOfStatement(inErrorRecovery: boolean): boolean {
-            // Functions, variable statements and classes are allowed as a statement.  But as per
-            // the grammar, they also allow modifiers.  So we have to check for those statements 
-            // that might be following modifiers.This ensures that things work properly when
-            // incrementally parsing as the parser will produce the same FunctionDeclaraiton, 
-            // VariableStatement or ClassDeclaration, if it has the same text regardless of whether 
-            // it is inside a block or not.
-            if (isModifier(token)) {
-                let result = lookAhead(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers);
-                if (result) {
-                    return true;
+        function isIdentifierOrKeyword() {
+            return token >= SyntaxKind.Identifier;
+        }
+
+        function nextTokenIsIdentifierOrKeywordOnSameLine() {
+            nextToken();
+            return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak();
+        }
+
+        function parseDeclarationFlags(): StatementFlags {
+            while (true) {
+                switch (token) {
+                    case SyntaxKind.VarKeyword:
+                    case SyntaxKind.LetKeyword:
+                    case SyntaxKind.ConstKeyword:
+                    case SyntaxKind.FunctionKeyword:
+                    case SyntaxKind.ClassKeyword:
+                    case SyntaxKind.EnumKeyword:
+                        return StatementFlags.Statement;
+                    case SyntaxKind.InterfaceKeyword:
+                    case SyntaxKind.TypeKeyword:
+                        nextToken();
+                        return isIdentifierOrKeyword() ? StatementFlags.Statement : StatementFlags.None;
+                    case SyntaxKind.ModuleKeyword:
+                    case SyntaxKind.NamespaceKeyword:
+                        nextToken();
+                        return isIdentifierOrKeyword() || token === SyntaxKind.StringLiteral ? StatementFlags.ModuleElement : StatementFlags.None;
+                    case SyntaxKind.ImportKeyword:
+                        nextToken();
+                        return token === SyntaxKind.StringLiteral || token === SyntaxKind.AsteriskToken ||
+                            token === SyntaxKind.OpenBraceToken || isIdentifierOrKeyword() ?
+                            StatementFlags.ModuleElement : StatementFlags.None;
+                    case SyntaxKind.ExportKeyword:
+                        nextToken();
+                        if (token === SyntaxKind.EqualsToken || token === SyntaxKind.AsteriskToken ||
+                            token === SyntaxKind.OpenBraceToken || token === SyntaxKind.DefaultKeyword) {
+                            return StatementFlags.ModuleElement;
+                        }
+                        continue;
+                    case SyntaxKind.DeclareKeyword:
+                    case SyntaxKind.PublicKeyword:
+                    case SyntaxKind.PrivateKeyword:
+                    case SyntaxKind.ProtectedKeyword:
+                    case SyntaxKind.StaticKeyword:
+                        nextToken();
+                        continue;
+                    default:
+                        return StatementFlags.None;
                 }
             }
+        }
 
+        function getDeclarationFlags(): StatementFlags {
+            return lookAhead(parseDeclarationFlags);
+        }
+
+        function getStatementFlags(): StatementFlags {
             switch (token) {
+                case SyntaxKind.AtToken:
                 case SyntaxKind.SemicolonToken:
-                    // If we're in error recovery, then we don't want to treat ';' as an empty statement.
-                    // The problem is that ';' can show up in far too many contexts, and if we see one
-                    // and assume it's a statement, then we may bail out inappropriately from whatever
-                    // we're parsing.  For example, if we have a semicolon in the middle of a class, then
-                    // we really don't want to assume the class is over and we're on a statement in the
-                    // outer module.  We just want to consume and move on.
-                    return !inErrorRecovery;
                 case SyntaxKind.OpenBraceToken:
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
                 case SyntaxKind.FunctionKeyword:
                 case SyntaxKind.ClassKeyword:
+                case SyntaxKind.EnumKeyword:
                 case SyntaxKind.IfKeyword:
                 case SyntaxKind.DoKeyword:
                 case SyntaxKind.WhileKeyword:
@@ -3828,62 +3874,84 @@ module ts {
                 // however, we say they are here so that we may gracefully parse them and error later.
                 case SyntaxKind.CatchKeyword:
                 case SyntaxKind.FinallyKeyword:
-                    return true;
+                    return StatementFlags.Statement;
+
                 case SyntaxKind.ConstKeyword:
-                    // const keyword can precede enum keyword when defining constant enums
-                    // 'const enum' do not start statement.
-                    // In ES 6 'enum' is a future reserved keyword, so it should not be used as identifier
-                    let isConstEnum = lookAhead(nextTokenIsEnumKeyword);
-                    return !isConstEnum;
+                case SyntaxKind.ExportKeyword:
+                case SyntaxKind.ImportKeyword:
+                    return getDeclarationFlags();
+
+                case SyntaxKind.DeclareKeyword:
                 case SyntaxKind.InterfaceKeyword:
                 case SyntaxKind.ModuleKeyword:
                 case SyntaxKind.NamespaceKeyword:
-                case SyntaxKind.EnumKeyword:
                 case SyntaxKind.TypeKeyword:
-                    // When followed by an identifier, these do not start a statement but might
-                    // instead be following declarations
-                    if (isDeclarationStart()) {
-                        return false;
-                    }
+                    // When these don't start a declaration, they're an identifier in an expression statement
+                    return getDeclarationFlags() || StatementFlags.Statement;
 
                 case SyntaxKind.PublicKeyword:
                 case SyntaxKind.PrivateKeyword:
                 case SyntaxKind.ProtectedKeyword:
                 case SyntaxKind.StaticKeyword:
-                    // When followed by an identifier or keyword, these do not start a statement but
-                    // might instead be following type members
-                    if (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine)) {
-                        return false;
-                    }
+                    // When these don't start a declaration, they may be the start of a class member if an identifier
+                    // immediately follows. Otherwise they're an identifier in an expression statement.
+                    return getDeclarationFlags() ||
+                        (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? StatementFlags.None : StatementFlags.Statement);
+
                 default:
-                    return isStartOfExpression();
+                    return isStartOfExpression() ? StatementFlags.Statement : StatementFlags.None;
             }
         }
 
-        function nextTokenIsEnumKeyword() {
-            nextToken();
-            return token === SyntaxKind.EnumKeyword
+        function isStartOfStatement(): boolean {
+            return (getStatementFlags() & StatementFlags.Statement) !== 0;
         }
 
-        function nextTokenIsIdentifierOrKeywordOnSameLine() {
+        function isStartOfModuleElement(): boolean {
+            return (getStatementFlags() & StatementFlags.StatementOrModuleElement) !== 0;
+        }
+
+        function nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine() {
             nextToken();
-            return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak();
+            return !scanner.hasPrecedingLineBreak() &&
+                (isIdentifier() || token === SyntaxKind.OpenBraceToken || token === SyntaxKind.OpenBracketToken);
+        }
+
+        function isLetDeclaration() {
+            // It is let declaration if in strict mode or next token is identifier\open bracket\open curly on same line.
+            // otherwise it needs to be treated like identifier
+            return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine);
         }
 
         function parseStatement(): Statement {
+            return <Statement>parseModuleElementOfKind(StatementFlags.Statement);
+        }
+
+        function parseModuleElement(): ModuleElement {
+            return parseModuleElementOfKind(StatementFlags.StatementOrModuleElement);
+        }
+
+        function parseSourceElement(): ModuleElement {
+            return parseModuleElementOfKind(StatementFlags.StatementOrModuleElement);
+        }
+
+        function parseModuleElementOfKind(flags: StatementFlags): ModuleElement {
             switch (token) {
-                case SyntaxKind.OpenBraceToken:
-                    return parseBlock(/*ignoreMissingOpenBrace:*/ false, /*checkForStrictMode:*/ false);
-                case SyntaxKind.VarKeyword:
-                case SyntaxKind.ConstKeyword:
-                    // const here should always be parsed as const declaration because of check in 'isStatement'
-                    return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
-                case SyntaxKind.FunctionKeyword:
-                    return parseFunctionDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
-                case SyntaxKind.ClassKeyword:
-                    return parseClassDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
                 case SyntaxKind.SemicolonToken:
                     return parseEmptyStatement();
+                case SyntaxKind.OpenBraceToken:
+                    return parseBlock(/*ignoreMissingOpenBrace*/ false, /*checkForStrictMode*/ false);
+                case SyntaxKind.VarKeyword:
+                    return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                case SyntaxKind.LetKeyword:
+                    if (isLetDeclaration()) {
+                        return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                    }
+                    break;
+                case SyntaxKind.FunctionKeyword:
+                    return parseFunctionDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
+                case SyntaxKind.ClassKeyword:
+                    return parseClassDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers*/ undefined);
                 case SyntaxKind.IfKeyword:
                     return parseIfStatement();
                 case SyntaxKind.DoKeyword:
@@ -3911,61 +3979,69 @@ module ts {
                     return parseTryStatement();
                 case SyntaxKind.DebuggerKeyword:
                     return parseDebuggerStatement();
-                case SyntaxKind.LetKeyword:
-                    // If let follows identifier on the same line, it is declaration parse it as variable statement
-                    if (isLetDeclaration()) {
-                        return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
+                case SyntaxKind.AtToken:
+                    return parseDeclaration();
+                case SyntaxKind.ConstKeyword:
+                case SyntaxKind.DeclareKeyword:
+                case SyntaxKind.EnumKeyword:
+                case SyntaxKind.ExportKeyword:
+                case SyntaxKind.ImportKeyword:
+                case SyntaxKind.InterfaceKeyword:
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.NamespaceKeyword:
+                case SyntaxKind.PrivateKeyword:
+                case SyntaxKind.ProtectedKeyword:
+                case SyntaxKind.PublicKeyword:
+                case SyntaxKind.StaticKeyword:
+                case SyntaxKind.TypeKeyword:
+                    if (getDeclarationFlags() & flags) {
+                        return parseDeclaration();
                     }
-                // Else parse it like identifier - fall through
-                default:
-                    // Functions and variable statements are allowed as a statement.  But as per
-                    // the grammar, they also allow modifiers.  So we have to check for those
-                    // statements that might be following modifiers.  This ensures that things
-                    // work properly when incrementally parsing as the parser will produce the
-                    // same FunctionDeclaraiton or VariableStatement if it has the same text
-                    // regardless of whether it is inside a block or not.
-                    // Even though variable statements and function declarations cannot have decorators, 
-                    // we parse them here to provide better error recovery.
-                    if (isModifier(token) || token === SyntaxKind.AtToken) {
-                        let result = tryParse(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers);
-                        if (result) {
-                            return result;
-                        }
-                    }
-
-                    return parseExpressionOrLabeledStatement();
+                    break;
             }
+            return parseExpressionOrLabeledStatement();
         }
 
-        function parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers(): FunctionDeclaration | VariableStatement | ClassDeclaration {
-            let start = scanner.getStartPos();
+        function parseDeclaration(): ModuleElement {
+            let fullStart = getNodePos();
             let decorators = parseDecorators();
             let modifiers = parseModifiers();
             switch (token) {
-                case SyntaxKind.ConstKeyword:
-                    let nextTokenIsEnum = lookAhead(nextTokenIsEnumKeyword)
-                    if (nextTokenIsEnum) {
-                        return undefined;
-                    }
-                    return parseVariableStatement(start, decorators, modifiers);
-
-                case SyntaxKind.LetKeyword:
-                    if (!isLetDeclaration()) {
-                        return undefined;
-                    }
-                    return parseVariableStatement(start, decorators, modifiers);
-
                 case SyntaxKind.VarKeyword:
-                    return parseVariableStatement(start, decorators, modifiers);
-
+                case SyntaxKind.LetKeyword:
+                case SyntaxKind.ConstKeyword:
+                    return parseVariableStatement(fullStart, decorators, modifiers);
                 case SyntaxKind.FunctionKeyword:
-                    return parseFunctionDeclaration(start, decorators, modifiers);
-
+                    return parseFunctionDeclaration(fullStart, decorators, modifiers);
                 case SyntaxKind.ClassKeyword:
-                    return parseClassDeclaration(start, decorators, modifiers);
+                    return parseClassDeclaration(fullStart, decorators, modifiers);
+                case SyntaxKind.InterfaceKeyword:
+                    return parseInterfaceDeclaration(fullStart, decorators, modifiers);
+                case SyntaxKind.TypeKeyword:
+                    return parseTypeAliasDeclaration(fullStart, decorators, modifiers);
+                case SyntaxKind.EnumKeyword:
+                    return parseEnumDeclaration(fullStart, decorators, modifiers);
+                case SyntaxKind.ModuleKeyword:
+                case SyntaxKind.NamespaceKeyword:
+                    return parseModuleDeclaration(fullStart, decorators, modifiers);
+                case SyntaxKind.ImportKeyword:
+                    return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers);
+                case SyntaxKind.ExportKeyword:
+                    nextToken();
+                    return token === SyntaxKind.DefaultKeyword || token === SyntaxKind.EqualsToken ?
+                        parseExportAssignment(fullStart, decorators, modifiers) :
+                        parseExportDeclaration(fullStart, decorators, modifiers);
+                default:
+                    if (decorators) {
+                        // We reached this point because we encountered decorators and/or modifiers and assumed a declaration
+                        // would follow. For recovery and error reporting purposes, return an incomplete declaration.                        
+                        let node = <ModuleElement>createMissingNode(SyntaxKind.MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected);
+                        node.pos = fullStart;
+                        node.decorators = decorators;
+                        setModifiers(node, modifiers);
+                        return finishNode(node);
+                    }
             }
-
-            return undefined;
         }
 
         function parseFunctionBlockOrSemicolon(isGenerator: boolean, diagnosticMessage?: DiagnosticMessage): Block {
@@ -3974,7 +4050,7 @@ module ts {
                 return;
             }
 
-            return parseFunctionBlock(isGenerator, /*ignoreMissingOpenBrace:*/ false, diagnosticMessage);
+            return parseFunctionBlock(isGenerator, /*ignoreMissingOpenBrace*/ false, diagnosticMessage);
         }
 
         // DECLARATIONS
@@ -4097,7 +4173,7 @@ module ts {
             let node = <VariableStatement>createNode(SyntaxKind.VariableStatement, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
-            node.declarationList = parseVariableDeclarationList(/*inForStatementInitializer:*/ false);
+            node.declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false);
             parseSemicolon();
             return finishNode(node);
         }
@@ -4109,7 +4185,7 @@ module ts {
             parseExpected(SyntaxKind.FunctionKeyword);
             node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
             node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier();
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ !!node.asteriskToken, /*requireCompleteParameterList:*/ false, node);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ !!node.asteriskToken, /*requireCompleteParameterList*/ false, node);
             node.body = parseFunctionBlockOrSemicolon(!!node.asteriskToken, Diagnostics.or_expected);
             return finishNode(node);
         }
@@ -4119,8 +4195,8 @@ module ts {
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ConstructorKeyword);
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node);
-            node.body = parseFunctionBlockOrSemicolon(/*isGenerator:*/ false, Diagnostics.or_expected);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false, Diagnostics.or_expected);
             return finishNode(node);
         }
 
@@ -4131,7 +4207,7 @@ module ts {
             method.asteriskToken = asteriskToken;
             method.name = name;
             method.questionToken = questionToken;
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ !!asteriskToken, /*requireCompleteParameterList:*/ false, method);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ !!asteriskToken, /*requireCompleteParameterList*/ false, method);
             method.body = parseFunctionBlockOrSemicolon(!!asteriskToken, diagnosticMessage);
             return finishNode(method);
         }
@@ -4143,7 +4219,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);
         }
@@ -4172,8 +4261,8 @@ module ts {
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.name = parsePropertyName();
-            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext:*/ false, /*requireCompleteParameterList:*/ false, node);
-            node.body = parseFunctionBlockOrSemicolon(/*isGenerator:*/ false);
+            fillSignature(SyntaxKind.ColonToken, /*yieldAndGeneratorParameterContext*/ false, /*requireCompleteParameterList*/ false, node);
+            node.body = parseFunctionBlockOrSemicolon(/*isGenerator*/ false);
             return finishNode(node);
         }
 
@@ -4352,9 +4441,9 @@ module ts {
 
         function parseClassExpression(): ClassExpression {
             return <ClassExpression>parseClassDeclarationOrExpression(
-                /*fullStart:*/ scanner.getStartPos(),
-                /*decorators:*/ undefined,
-                /*modifiers:*/ undefined,
+                /*fullStart*/ scanner.getStartPos(),
+                /*decorators*/ undefined,
+                /*modifiers*/ undefined,
                 SyntaxKind.ClassExpression);
         }
 
@@ -4373,7 +4462,7 @@ module ts {
             parseExpected(SyntaxKind.ClassKeyword);
             node.name = parseOptionalIdentifier();
             node.typeParameters = parseTypeParameters();
-            node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause:*/ true);
+            node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ true);
 
             if (parseExpected(SyntaxKind.OpenBraceToken)) {
                 // ClassTail[Yield,GeneratorParameter] : See 14.5
@@ -4409,7 +4498,7 @@ module ts {
         }
 
         function parseHeritageClausesWorker() {
-            return parseList(ParsingContext.HeritageClauses, /*checkForStrictMode:*/ false, parseHeritageClause);
+            return parseList(ParsingContext.HeritageClauses, /*checkForStrictMode*/ false, parseHeritageClause);
         }
 
         function parseHeritageClause() {
@@ -4449,7 +4538,7 @@ module ts {
             parseExpected(SyntaxKind.InterfaceKeyword);
             node.name = parseIdentifier();
             node.typeParameters = parseTypeParameters();
-            node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause:*/ false);
+            node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ false);
             node.members = parseObjectTypeMembers();
             return finishNode(node);
         }
@@ -4512,7 +4601,7 @@ module ts {
             node.flags |= flags;
             node.name = parseIdentifier();
             node.body = parseOptional(SyntaxKind.DotToken)
-                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers:*/undefined, NodeFlags.Export)
+                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, NodeFlags.Export)
                 : parseModuleBlock();
             return finishNode(node);
         }
@@ -4521,7 +4610,7 @@ module ts {
             let node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
-            node.name = parseLiteralNode(/*internName:*/ true);
+            node.name = parseLiteralNode(/*internName*/ true);
             node.body = parseModuleBlock();
             return finishNode(node);
         }
@@ -4748,151 +4837,6 @@ module ts {
             return finishNode(node);
         }
 
-        function isLetDeclaration() {
-            // It is let declaration if in strict mode or next token is identifier\open bracket\open curly on same line.
-            // otherwise it needs to be treated like identifier
-            return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOrStartOfDestructuringOnTheSameLine);
-        }
-
-        function isDeclarationStart(followsModifier?: boolean): boolean {
-            switch (token) {
-                case SyntaxKind.VarKeyword:
-                case SyntaxKind.ConstKeyword:
-                case SyntaxKind.FunctionKeyword:
-                    return true;
-                case SyntaxKind.LetKeyword:
-                    return isLetDeclaration();
-                case SyntaxKind.ClassKeyword:
-                case SyntaxKind.InterfaceKeyword:
-                case SyntaxKind.EnumKeyword:
-                case SyntaxKind.TypeKeyword:
-                    // Not true keywords so ensure an identifier follows
-                    return lookAhead(nextTokenIsIdentifierOrKeyword);
-                case SyntaxKind.ImportKeyword:
-                    // Not true keywords so ensure an identifier follows or is string literal or asterisk or open brace
-                    return lookAhead(nextTokenCanFollowImportKeyword);
-                case SyntaxKind.ModuleKeyword:
-                case SyntaxKind.NamespaceKeyword:
-                    // Not a true keyword so ensure an identifier or string literal follows
-                    return lookAhead(nextTokenIsIdentifierOrKeywordOrStringLiteral);
-                case SyntaxKind.ExportKeyword:
-                    // Check for export assignment or modifier on source element
-                    return lookAhead(nextTokenCanFollowExportKeyword);
-                case SyntaxKind.DeclareKeyword:
-                case SyntaxKind.PublicKeyword:
-                case SyntaxKind.PrivateKeyword:
-                case SyntaxKind.ProtectedKeyword:
-                case SyntaxKind.StaticKeyword:
-                    // Check for modifier on source element
-                    return lookAhead(nextTokenIsDeclarationStart);
-                case SyntaxKind.AtToken:
-                    // a lookahead here is too costly, and decorators are only valid on a declaration. 
-                    // We will assume we are parsing a declaration here and report an error later
-                    return !followsModifier;
-            }
-        }
-
-        function isIdentifierOrKeyword() {
-            return token >= SyntaxKind.Identifier;
-        }
-
-        function nextTokenIsIdentifierOrKeyword() {
-            nextToken();
-            return isIdentifierOrKeyword();
-        }
-
-        function nextTokenIsIdentifierOrKeywordOrStringLiteral() {
-            nextToken();
-            return isIdentifierOrKeyword() || token === SyntaxKind.StringLiteral;
-        }
-
-        function nextTokenCanFollowImportKeyword() {
-            nextToken();
-            return isIdentifierOrKeyword() || token === SyntaxKind.StringLiteral ||
-                token === SyntaxKind.AsteriskToken || token === SyntaxKind.OpenBraceToken;
-        }
-
-        function nextTokenCanFollowExportKeyword() {
-            nextToken();
-            return token === SyntaxKind.EqualsToken || token === SyntaxKind.AsteriskToken ||
-                token === SyntaxKind.OpenBraceToken || token === SyntaxKind.DefaultKeyword || isDeclarationStart(/*followsModifier*/ true);
-        }
-
-        function nextTokenIsDeclarationStart() {
-            nextToken();
-            return isDeclarationStart(/*followsModifier*/ true);
-        }
-
-        function nextTokenIsAsKeyword() {
-            return nextToken() === SyntaxKind.AsKeyword;
-        }
-
-        function parseDeclaration(): ModuleElement {
-            let fullStart = getNodePos();
-            let decorators = parseDecorators();
-            let modifiers = parseModifiers();
-            if (token === SyntaxKind.ExportKeyword) {
-                nextToken();
-                if (token === SyntaxKind.DefaultKeyword || token === SyntaxKind.EqualsToken) {
-                    return parseExportAssignment(fullStart, decorators, modifiers);
-                }
-                if (token === SyntaxKind.AsteriskToken || token === SyntaxKind.OpenBraceToken) {
-                    return parseExportDeclaration(fullStart, decorators, modifiers);
-                }
-            }
-
-            switch (token) {
-                case SyntaxKind.VarKeyword:
-                case SyntaxKind.LetKeyword:
-                case SyntaxKind.ConstKeyword:
-                    return parseVariableStatement(fullStart, decorators, modifiers);
-                case SyntaxKind.FunctionKeyword:
-                    return parseFunctionDeclaration(fullStart, decorators, modifiers);
-                case SyntaxKind.ClassKeyword:
-                    return parseClassDeclaration(fullStart, decorators, modifiers);
-                case SyntaxKind.InterfaceKeyword:
-                    return parseInterfaceDeclaration(fullStart, decorators, modifiers);
-                case SyntaxKind.TypeKeyword:
-                    return parseTypeAliasDeclaration(fullStart, decorators, modifiers);
-                case SyntaxKind.EnumKeyword:
-                    return parseEnumDeclaration(fullStart, decorators, modifiers);
-                case SyntaxKind.ModuleKeyword:
-                case SyntaxKind.NamespaceKeyword:
-                    return parseModuleDeclaration(fullStart, decorators, modifiers);
-                case SyntaxKind.ImportKeyword:
-                    return parseImportDeclarationOrImportEqualsDeclaration(fullStart, decorators, modifiers);
-                default:
-                    if (decorators) {
-                        // We reached this point because we encountered an AtToken and assumed a declaration would
-                        // follow. For recovery and error reporting purposes, return an incomplete declaration.                        
-                        let node = <ModuleElement>createMissingNode(SyntaxKind.MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected);
-                        node.pos = fullStart;
-                        node.decorators = decorators;
-                        setModifiers(node, modifiers);
-                        return finishNode(node);
-                    }
-                    Debug.fail("Mismatch between isDeclarationStart and parseDeclaration");
-            }
-        }
-
-        function isSourceElement(inErrorRecovery: boolean): boolean {
-            return isDeclarationStart() || isStartOfStatement(inErrorRecovery);
-        }
-
-        function parseSourceElement() {
-            return parseSourceElementOrModuleElement();
-        }
-
-        function parseModuleElement() {
-            return parseSourceElementOrModuleElement();
-        }
-
-        function parseSourceElementOrModuleElement(): ModuleElement {
-            return isDeclarationStart()
-                ? parseDeclaration()
-                : parseStatement();
-        }
-
         function processReferenceComments(sourceFile: SourceFile): void {
             let triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, sourceText);
             let referencedFiles: FileReference[] = [];
@@ -5899,7 +5843,7 @@ module ts {
                 if (child.pos > changeRangeOldEnd) {
                     // Node is entirely past the change range.  We need to move both its pos and
                     // end, forward or backward appropriately.
-                    moveElementEntirelyPastChangeRange(child, /*isArray:*/ false, delta, oldText, newText, aggressiveChecks);
+                    moveElementEntirelyPastChangeRange(child, /*isArray*/ false, delta, oldText, newText, aggressiveChecks);
                     return;
                 }
 
@@ -5928,7 +5872,7 @@ module ts {
                 if (array.pos > changeRangeOldEnd) {
                     // Array is entirely after the change range.  We need to move it, and move any of
                     // its children.
-                    moveElementEntirelyPastChangeRange(array, /*isArray:*/ true, delta, oldText, newText, aggressiveChecks);
+                    moveElementEntirelyPastChangeRange(array, /*isArray*/ true, delta, oldText, newText, aggressiveChecks);
                     return;
                 }
 
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index f9daf52c5f2..1a7d9de47a1 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -231,7 +231,7 @@ module ts {
                     var directories: string[] = [];
                     for (let current of files) {
                         var name = combinePaths(path, current);
-                        var stat = _fs.lstatSync(name);
+                        var stat = _fs.statSync(name);
                         if (stat.isFile()) {
                             if (!extension || fileExtensionIs(name, extension)) {
                                 result.push(name);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 85fa461daab..14e53ee8f72 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 {
@@ -917,7 +917,7 @@ module ts {
         _classElementBrand: any;
     }
 
-    export interface InterfaceDeclaration extends Declaration, ModuleElement {
+    export interface InterfaceDeclaration extends Declaration, Statement {
         name: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
@@ -929,7 +929,7 @@ module ts {
         types?: NodeArray<ExpressionWithTypeArguments>;
     }
 
-    export interface TypeAliasDeclaration extends Declaration, ModuleElement {
+    export interface TypeAliasDeclaration extends Declaration, Statement {
         name: Identifier;
         type: TypeNode;
     }
@@ -941,7 +941,7 @@ module ts {
         initializer?: Expression;
     }
 
-    export interface EnumDeclaration extends Declaration, ModuleElement {
+    export interface EnumDeclaration extends Declaration, Statement {
         name: Identifier;
         members: NodeArray<EnumMember>;
     }
@@ -1626,6 +1626,8 @@ module ts {
     // Class and interface types (TypeFlags.Class and TypeFlags.Interface)
     export interface InterfaceType extends ObjectType {
         typeParameters: TypeParameter[];           // Type parameters (undefined if non-generic)
+        outerTypeParameters: TypeParameter[];      // Outer type parameters (undefined if none)
+        localTypeParameters: TypeParameter[];      // Local type parameters (undefined if none)
     }
 
     export interface InterfaceTypeWithBaseTypes extends InterfaceType {
@@ -1676,6 +1678,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 4aca0859cee..5198d8a2288 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 1403efae348..625a4eca9e1 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 4686616c3cc..9cf6d8ff4bc 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/services.ts b/src/services/services.ts
index 1019c532192..4e441e40d87 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -2475,6 +2475,10 @@ module ts {
                 }
             }
 
+            // hostCache is captured in the closure for 'getOrCreateSourceFile' but it should not be used past this point.
+            // It needs to be cleared to allow all collected snapshots to be released
+            hostCache = undefined;
+
             program = newProgram;
 
             // Make sure all the nodes in the program are both bound, and have their parent 
@@ -2483,6 +2487,7 @@ module ts {
             return;
 
             function getOrCreateSourceFile(fileName: string): SourceFile {
+                Debug.assert(hostCache !== undefined);
                 // The program is asking for this file, check first if the host can locate it.
                 // If the host can not locate the file, then it does not exist. return undefined
                 // to the program to allow reporting of errors for missing files.
diff --git a/src/services/shims.ts b/src/services/shims.ts
index 27c70ddc878..d3f59737538 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 8c6b09c82d6..c0a45a2be52 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 1dd8c3f6a1b..2c674a63f93 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 a46097e8a1a..aeb9e1fa6a6 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 71b09983939..e3601968a27 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 b5ea3f494a7..27981b028ed 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 f129d3fa30b..45e88ed7efb 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 152b1ffc7cc..b17b945e2f4 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 979178fd4b7..0bc04c80860 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 ab27947d7c5..e58fe7ab4c7 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 bbabbc97463..ebbc2a4dbe1 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 596764e58ea..b2b071ee5e6 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 9d4e312ed22..0da724d7ec3 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 6373c800994..8801b74cae5 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 826c1d7fd75..458a3da62bb 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 ea87da50ed3..210485e629f 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 e0d7ea4ad27..a4bf2a8eb8f 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 3f322a81f2f..1272295fe5f 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 10843421a3f..42d447ed5d6 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 fc2d885d381..57329bb142d 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 baeaf3ba30e..2e32e7a2388 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 5e548799f5d..bb60f6a8f76 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 c0d2e4c8fc8..8eb7a7be4cf 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 b39f47b07f9..bc262212526 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 3a67acdebcd..056fc0e950a 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 9d04d9559b0..7d7db15ebb6 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 553dab51fc2..2d1a7082d53 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 1e284c92786..01bd5a54d59 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 2d2a7ca3257..dbb543ba86e 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 a3d9481601a..a90cc45d24f 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 393a03ee269..067d11ecde6 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 3f7933c5bb2..32ee997e38a 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 cd753647327..2bd42847e64 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 00000000000..9ba5e44f9aa
--- /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 00000000000..742c5b7d1e7
--- /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 00000000000..3d0c89fd23f
--- /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 00000000000..5b40963d9a2
--- /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 00000000000..25cecc80444
--- /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 00000000000..7463fc01bc1
--- /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 00000000000..6247a366ba8
--- /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 00000000000..6283b81cca3
--- /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/classDeclarationBlockScoping1.errors.txt b/tests/baselines/reference/classDeclarationBlockScoping1.errors.txt
deleted file mode 100644
index 4f15007bb2a..00000000000
--- a/tests/baselines/reference/classDeclarationBlockScoping1.errors.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-tests/cases/compiler/classDeclarationBlockScoping1.ts(5,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-
-
-==== tests/cases/compiler/classDeclarationBlockScoping1.ts (1 errors) ====
-    class C {
-    }
-    
-    {
-        class C {
-              ~
-!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-        }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/classDeclarationBlockScoping1.symbols b/tests/baselines/reference/classDeclarationBlockScoping1.symbols
new file mode 100644
index 00000000000..645d327e256
--- /dev/null
+++ b/tests/baselines/reference/classDeclarationBlockScoping1.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/classDeclarationBlockScoping1.ts ===
+class C {
+>C : Symbol(C, Decl(classDeclarationBlockScoping1.ts, 0, 0))
+}
+
+{
+    class C {
+>C : Symbol(C, Decl(classDeclarationBlockScoping1.ts, 3, 1))
+    }
+}
diff --git a/tests/baselines/reference/classDeclarationBlockScoping1.types b/tests/baselines/reference/classDeclarationBlockScoping1.types
new file mode 100644
index 00000000000..9020ca4a23a
--- /dev/null
+++ b/tests/baselines/reference/classDeclarationBlockScoping1.types
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/classDeclarationBlockScoping1.ts ===
+class C {
+>C : C
+}
+
+{
+    class C {
+>C : C
+    }
+}
diff --git a/tests/baselines/reference/classDeclarationBlockScoping2.errors.txt b/tests/baselines/reference/classDeclarationBlockScoping2.errors.txt
deleted file mode 100644
index 2a9885e110b..00000000000
--- a/tests/baselines/reference/classDeclarationBlockScoping2.errors.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-tests/cases/compiler/classDeclarationBlockScoping2.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-tests/cases/compiler/classDeclarationBlockScoping2.ts(5,15): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-
-
-==== tests/cases/compiler/classDeclarationBlockScoping2.ts (2 errors) ====
-    function f() {
-        class C {}
-              ~
-!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-        var c1 = C;
-        {
-            class C {}
-                  ~
-!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-            var c2 = C;
-        }
-        return C === c1;
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/classDeclarationBlockScoping2.symbols b/tests/baselines/reference/classDeclarationBlockScoping2.symbols
new file mode 100644
index 00000000000..cece47c3ee7
--- /dev/null
+++ b/tests/baselines/reference/classDeclarationBlockScoping2.symbols
@@ -0,0 +1,22 @@
+=== tests/cases/compiler/classDeclarationBlockScoping2.ts ===
+function f() {
+>f : Symbol(f, Decl(classDeclarationBlockScoping2.ts, 0, 0))
+
+    class C {}
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 0, 14))
+
+    var c1 = C;
+>c1 : Symbol(c1, Decl(classDeclarationBlockScoping2.ts, 2, 7))
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 0, 14))
+    {
+        class C {}
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 3, 5))
+
+        var c2 = C;
+>c2 : Symbol(c2, Decl(classDeclarationBlockScoping2.ts, 5, 11))
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 3, 5))
+    }
+    return C === c1;
+>C : Symbol(C, Decl(classDeclarationBlockScoping2.ts, 0, 14))
+>c1 : Symbol(c1, Decl(classDeclarationBlockScoping2.ts, 2, 7))
+}
diff --git a/tests/baselines/reference/classDeclarationBlockScoping2.types b/tests/baselines/reference/classDeclarationBlockScoping2.types
new file mode 100644
index 00000000000..0431d4dd2fd
--- /dev/null
+++ b/tests/baselines/reference/classDeclarationBlockScoping2.types
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/classDeclarationBlockScoping2.ts ===
+function f() {
+>f : () => boolean
+
+    class C {}
+>C : C
+
+    var c1 = C;
+>c1 : typeof C
+>C : typeof C
+    {
+        class C {}
+>C : C
+
+        var c2 = C;
+>c2 : typeof C
+>C : typeof C
+    }
+    return C === c1;
+>C === c1 : boolean
+>C : typeof C
+>c1 : typeof C
+}
diff --git a/tests/baselines/reference/classExpressionTest1.errors.txt b/tests/baselines/reference/classExpressionTest1.errors.txt
deleted file mode 100644
index 4d7e1cda639..00000000000
--- a/tests/baselines/reference/classExpressionTest1.errors.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-tests/cases/compiler/classExpressionTest1.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-
-
-==== tests/cases/compiler/classExpressionTest1.ts (1 errors) ====
-    function M() {
-        class C<X> {
-              ~
-!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-            f<T>() {
-                var t: T;
-                var x: X;
-                return { t, x };
-            }
-        }
-    
-        var v = new C<number>();
-        return v.f<string>();
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/classExpressionTest1.symbols b/tests/baselines/reference/classExpressionTest1.symbols
new file mode 100644
index 00000000000..684ee302895
--- /dev/null
+++ b/tests/baselines/reference/classExpressionTest1.symbols
@@ -0,0 +1,35 @@
+=== tests/cases/compiler/classExpressionTest1.ts ===
+function M() {
+>M : Symbol(M, Decl(classExpressionTest1.ts, 0, 0))
+
+    class C<X> {
+>C : Symbol(C, Decl(classExpressionTest1.ts, 0, 14))
+>X : Symbol(X, Decl(classExpressionTest1.ts, 1, 12))
+
+        f<T>() {
+>f : Symbol(f, Decl(classExpressionTest1.ts, 1, 16))
+>T : Symbol(T, Decl(classExpressionTest1.ts, 2, 10))
+
+            var t: T;
+>t : Symbol(t, Decl(classExpressionTest1.ts, 3, 15))
+>T : Symbol(T, Decl(classExpressionTest1.ts, 2, 10))
+
+            var x: X;
+>x : Symbol(x, Decl(classExpressionTest1.ts, 4, 15))
+>X : Symbol(X, Decl(classExpressionTest1.ts, 1, 12))
+
+            return { t, x };
+>t : Symbol(t, Decl(classExpressionTest1.ts, 5, 20))
+>x : Symbol(x, Decl(classExpressionTest1.ts, 5, 23))
+        }
+    }
+
+    var v = new C<number>();
+>v : Symbol(v, Decl(classExpressionTest1.ts, 9, 7))
+>C : Symbol(C, Decl(classExpressionTest1.ts, 0, 14))
+
+    return v.f<string>();
+>v.f : Symbol(C.f, Decl(classExpressionTest1.ts, 1, 16))
+>v : Symbol(v, Decl(classExpressionTest1.ts, 9, 7))
+>f : Symbol(C.f, Decl(classExpressionTest1.ts, 1, 16))
+}
diff --git a/tests/baselines/reference/classExpressionTest1.types b/tests/baselines/reference/classExpressionTest1.types
new file mode 100644
index 00000000000..bf1ae0f2f7d
--- /dev/null
+++ b/tests/baselines/reference/classExpressionTest1.types
@@ -0,0 +1,38 @@
+=== tests/cases/compiler/classExpressionTest1.ts ===
+function M() {
+>M : () => { t: string; x: number; }
+
+    class C<X> {
+>C : C<X>
+>X : X
+
+        f<T>() {
+>f : <T>() => { t: T; x: X; }
+>T : T
+
+            var t: T;
+>t : T
+>T : T
+
+            var x: X;
+>x : X
+>X : X
+
+            return { t, x };
+>{ t, x } : { t: T; x: X; }
+>t : T
+>x : X
+        }
+    }
+
+    var v = new C<number>();
+>v : C<number>
+>new C<number>() : C<number>
+>C : typeof C
+
+    return v.f<string>();
+>v.f<string>() : { t: string; x: number; }
+>v.f : <T>() => { t: T; x: number; }
+>v : C<number>
+>f : <T>() => { t: T; x: number; }
+}
diff --git a/tests/baselines/reference/classInsideBlock.errors.txt b/tests/baselines/reference/classInsideBlock.errors.txt
deleted file mode 100644
index 369e77735e2..00000000000
--- a/tests/baselines/reference/classInsideBlock.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-
-
-==== tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts (1 errors) ====
-    function foo() {
-        class C { }
-              ~
-!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/classInsideBlock.symbols b/tests/baselines/reference/classInsideBlock.symbols
new file mode 100644
index 00000000000..5f96dd1b751
--- /dev/null
+++ b/tests/baselines/reference/classInsideBlock.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts ===
+function foo() {
+>foo : Symbol(foo, Decl(classInsideBlock.ts, 0, 0))
+
+    class C { }
+>C : Symbol(C, Decl(classInsideBlock.ts, 0, 16))
+}
diff --git a/tests/baselines/reference/classInsideBlock.types b/tests/baselines/reference/classInsideBlock.types
new file mode 100644
index 00000000000..7db5653c475
--- /dev/null
+++ b/tests/baselines/reference/classInsideBlock.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts ===
+function foo() {
+>foo : () => void
+
+    class C { }
+>C : C
+}
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index ce86a2bd59a..48564baf796 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 f396414521e..5f62de9bfa1 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 b484e2d72e1..b54ac35ba78 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 10c43123fa3..df900ac860e 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 4598ec0a305..4d0887c1ff8 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 019f44118ce..739d9be0af0 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 db15a4dcb87..9322fea69e6 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 625ee544225..72bbf78884e 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 343c5a38c97..e1e7717269f 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 f16364548ce..571dd9dc389 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/functionsWithModifiersInBlocks1.errors.txt b/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt
index 94e246f8972..f6240f5e697 100644
--- a/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt
+++ b/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt
@@ -4,12 +4,11 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(2,25): error TS1184: An
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(3,4): error TS1184: Modifiers cannot appear here.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(3,20): error TS2393: Duplicate function implementation.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,4): error TS1184: Modifiers cannot appear here.
-tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,12): error TS1029: 'export' modifier must precede 'declare' modifier.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,28): error TS2393: Duplicate function implementation.
 tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
-==== tests/cases/compiler/functionsWithModifiersInBlocks1.ts (9 errors) ====
+==== tests/cases/compiler/functionsWithModifiersInBlocks1.ts (8 errors) ====
     {
        declare function f() { }
        ~~~~~~~
@@ -26,8 +25,6 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An
        declare export function f() { }
        ~~~~~~~
 !!! error TS1184: Modifiers cannot appear here.
-               ~~~~~~
-!!! error TS1029: 'export' modifier must precede 'declare' modifier.
                                ~
 !!! error TS2393: Duplicate function implementation.
                                    ~
diff --git a/tests/baselines/reference/generatorES6_1.errors.txt b/tests/baselines/reference/generatorES6_1.errors.txt
deleted file mode 100644
index b02da7f0b53..00000000000
--- 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 00000000000..fc5aa602e01
--- /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 00000000000..13ac7c05844
--- /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 8d956fc7f63..00000000000
--- 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 00000000000..a64b1304692
--- /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 00000000000..9c9c8692757
--- /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 e1c1d918ce6..00000000000
--- 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 00000000000..329c96e6de8
--- /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 00000000000..e87ad23ba77
--- /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 37c375e9728..00000000000
--- 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 00000000000..fc514dad45f
--- /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 00000000000..64b0924919b
--- /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 f6fa8a5bc18..20e6f3abe9f 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 1f568aeb9e4..00000000000
--- 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 00000000000..4cdac0f12c5
--- /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 00000000000..4e3de8cea1e
--- /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 00000000000..fcfcceb9ff5
--- /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 00000000000..e7b4e03e64e
--- /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 00000000000..8f471ef98bc
--- /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 00000000000..f7742ccc235
--- /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 00000000000..44391cab730
--- /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 00000000000..2b1701156f0
--- /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 00000000000..044155e8dd5
--- /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 00000000000..78139a7e597
--- /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 00000000000..169aba8201b
--- /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 00000000000..10cfa85d933
--- /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 00000000000..e921a2b1f96
--- /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 00000000000..d960126210e
--- /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 00000000000..9d2b5a2ee41
--- /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 00000000000..0ce5ae10f4d
--- /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 00000000000..53dad48de63
--- /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 00000000000..4fa3837ed36
--- /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 00000000000..c68e2fac0b0
--- /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 00000000000..55ba5dcdc99
--- /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 00000000000..8ebbcb59381
--- /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 00000000000..afae1c1a808
--- /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 00000000000..493e0ac307c
--- /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 00000000000..c6d928045fa
--- /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 00000000000..0a14548d197
--- /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 00000000000..276baf1ff40
--- /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 00000000000..eb3cbcd2fe0
--- /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 00000000000..58ee2aa66f8
--- /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 00000000000..3f02fe4b095
--- /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 00000000000..252f3011613
--- /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 00000000000..c6eeb6b4a3d
--- /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 00000000000..f9304e3b168
--- /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 00000000000..4898f661f26
--- /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 00000000000..b904dfb446b
--- /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 00000000000..ce47d497851
--- /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 00000000000..058b0a0772d
--- /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 00000000000..e596203b9eb
--- /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 00000000000..3dd3c20f18d
--- /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 00000000000..26308b0ac7e
--- /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 00000000000..84e42a06cfd
--- /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 00000000000..d77b630ae72
--- /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 00000000000..a7dcc87a3a9
--- /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 00000000000..36d10d88545
--- /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 00000000000..db1b5bde19a
--- /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 00000000000..d359c100486
--- /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 00000000000..3d914d0bd6f
--- /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 00000000000..4437d78572d
--- /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 00000000000..7b8b93deabd
--- /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 00000000000..bbc22cc4a2d
--- /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 00000000000..a607ad851c1
--- /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 00000000000..8c3ebb59ea6
--- /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 00000000000..9e689d9df42
--- /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 00000000000..0ea7212040b
--- /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 00000000000..2c6deab9821
--- /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 00000000000..5907dd14b29
--- /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 00000000000..375d7b36ecc
--- /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 00000000000..2edec8fd21a
--- /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 00000000000..2b4f1396c2e
--- /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 00000000000..559946b0fcb
--- /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 00000000000..e0668786598
--- /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 00000000000..882367fa3d4
--- /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 00000000000..c6e8200d106
--- /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 00000000000..c7336079bf0
--- /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 00000000000..0ef66aa1bd7
--- /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 00000000000..83d1007a2c2
--- /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 00000000000..ab2b3de4f42
--- /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 00000000000..0045e115e6f
--- /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 00000000000..9e85117a0a8
--- /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 00000000000..37c2c239e2c
--- /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 00000000000..b4ca13c14c2
--- /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 00000000000..8b6018243ca
--- /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 00000000000..8d414c7c471
--- /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 00000000000..894561bcc93
--- /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 00000000000..d5c1a4c7947
--- /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 00000000000..4d3ad862565
--- /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 00000000000..8141a866c8e
--- /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 00000000000..528d510bed2
--- /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 00000000000..bfff5f9e10a
--- /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 00000000000..7b120cfffc4
--- /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 00000000000..e94fd9b7e38
--- /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 00000000000..e1bbbd96b40
--- /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 00000000000..1afae072758
--- /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 00000000000..4f5204f89fc
--- /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 00000000000..57790d5b700
--- /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 00000000000..85cb32e5759
--- /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 00000000000..9d884a92f5e
--- /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 00000000000..2f5d2405507
--- /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 00000000000..9d2fb9d517d
--- /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 00000000000..e652dd1b55f
--- /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 00000000000..49c43ce135f
--- /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 00000000000..2ed94dff531
--- /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 00000000000..a0336b464a4
--- /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 00000000000..2037b0ec621
--- /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 00000000000..9312371d7eb
--- /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 00000000000..5ec8e9214f3
--- /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 00000000000..256e4c94be7
--- /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 00000000000..b1bda8808f2
--- /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 00000000000..f3b8af225d1
--- /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 00000000000..20b88b9a090
--- /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 00000000000..343b68c3bda
--- /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 00000000000..35063e988eb
--- /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 00000000000..e2b1c10850a
--- /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 00000000000..43271b79e9e
--- /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 00000000000..0bfc22ab3f0
--- /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 00000000000..a207860603b
--- /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 00000000000..dc7eb37fe30
--- /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 00000000000..110a4d3e02e
--- /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 00000000000..4c73dfe558a
--- /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 00000000000..8939c5382e2
--- /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 00000000000..e8611ec167a
--- /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 00000000000..de5258db785
--- /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 00000000000..83410159b1a
--- /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 00000000000..08503e8640f
--- /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 00000000000..eb89fa23291
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck39.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(5,16): error TS1163: A 'yield' expression is only allowed in a generator body.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts(7,13): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck39.ts (2 errors) ====
+    function decorator(x: any) {
+        return y => { };
+    }
+    function* g() {
+        @decorator(yield 0)
+                   ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
+        class C {
+            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/generatorTypeCheck39.js b/tests/baselines/reference/generatorTypeCheck39.js
new file mode 100644
index 00000000000..e6d25045a7e
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck39.js
@@ -0,0 +1,33 @@
+//// [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 00000000000..8c0d7aeddd1
--- /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 00000000000..fb7cd93e0d9
--- /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 00000000000..c90fda0c0fc
--- /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 00000000000..9d9676e5d28
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck40.errors.txt
@@ -0,0 +1,9 @@
+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 (1 errors) ====
+    function* g() {
+        class C extends (yield 0) { }
+                        ~~~~~~~~~
+!!! 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 00000000000..fe9bb797d77
--- /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 00000000000..51c5ce3d416
--- /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 00000000000..9111affa875
--- /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 00000000000..926aef95ce5
--- /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 00000000000..c58802b1a81
--- /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 00000000000..a49534fd211
--- /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 00000000000..855c4697f40
--- /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 00000000000..c7dc2dad393
--- /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 00000000000..f5f7b6c359f
--- /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 00000000000..50fc7e30c86
--- /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 00000000000..238998ad974
--- /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 00000000000..b6606064c43
--- /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 00000000000..2fc67f90556
--- /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 00000000000..20f64e53c9d
--- /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 00000000000..06340925fec
--- /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 00000000000..7ea442420d6
--- /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 00000000000..0270f9e3a33
--- /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 00000000000..aa0b237d1f2
--- /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 00000000000..daf0d67b6ec
--- /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 00000000000..f5264f7ce96
--- /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 00000000000..b06fb96b435
--- /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 00000000000..c91626cd813
--- /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 00000000000..579d6dcf0e1
--- /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 00000000000..b544c7e4225
--- /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 00000000000..d24deed3d80
--- /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 00000000000..f56cca33438
--- /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 00000000000..1acfc110578
--- /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 00000000000..3f889e3cadf
--- /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 00000000000..6918a00663c
--- /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 00000000000..856e3867ab6
--- /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 00000000000..412a1ac1ea7
--- /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 00000000000..342d7406dce
--- /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 00000000000..f4fc5723a5e
--- /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 00000000000..f3519065c3d
--- /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 00000000000..8dc280bb8c9
--- /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 00000000000..751e12c471f
--- /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 00000000000..ee3512f34c5
--- /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 00000000000..f26b3b60806
--- /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 00000000000..de22dbfc6e8
--- /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 00000000000..f53215404ef
--- /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 00000000000..0846d1c28ad
--- /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 00000000000..dd7cd33af29
--- /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 00000000000..99e3b00de41
--- /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 00000000000..c1b0f98f5e7
--- /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 00000000000..aa39e534d62
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck57.errors.txt
@@ -0,0 +1,11 @@
+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 (1 errors) ====
+    function* g() {
+        class C {
+            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 00000000000..740df492867
--- /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 00000000000..7407c83b34b
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck58.errors.txt
@@ -0,0 +1,11 @@
+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 (1 errors) ====
+    function* g() {
+        class C {
+            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 00000000000..925fc2b76d2
--- /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 00000000000..7f2c9b87529
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck59.errors.txt
@@ -0,0 +1,12 @@
+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 (1 errors) ====
+    function* g() {
+        class C {
+            @(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 00000000000..5b3b70386f8
--- /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 00000000000..35f2cc2016d
--- /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 00000000000..de0f92f77f1
--- /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 00000000000..d8e5d640bb1
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck60.errors.txt
@@ -0,0 +1,9 @@
+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 (1 errors) ====
+    function* g() {
+        class C extends (yield) {};
+                        ~~~~~~~
+!!! 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 00000000000..cb7c65cf081
--- /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 00000000000..87e844dbfb6
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck61.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts(2,7): error TS1163: A 'yield' expression is only allowed in a generator body.
+
+
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts (1 errors) ====
+    function * g() {
+        @(yield 0)
+          ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
+        class C {};
+    }
\ 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 00000000000..9e2f067f9fb
--- /dev/null
+++ b/tests/baselines/reference/generatorTypeCheck61.js
@@ -0,0 +1,23 @@
+//// [generatorTypeCheck61.ts]
+function * g() {
+    @(yield 0)
+    class C {};
+}
+
+//// [generatorTypeCheck61.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() {
+    let C = class {
+    };
+    C = __decorate([
+        (yield 0)
+    ], C);
+    ;
+}
diff --git a/tests/baselines/reference/generatorTypeCheck7.errors.txt b/tests/baselines/reference/generatorTypeCheck7.errors.txt
new file mode 100644
index 00000000000..2653ecf8cd5
--- /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 00000000000..c2d47f9483c
--- /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 00000000000..cedfecda60b
--- /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 00000000000..97058c2eaa0
--- /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 00000000000..3b4e0c654fb
--- /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 00000000000..3bdeec0a4a9
--- /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 00000000000..a5cf75ae7f3
--- /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 00000000000..3fee48fc837
--- /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 00000000000..da2fa24060f
--- /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 00000000000..fe53a619acd
--- /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 00000000000..fc8d39858b6
--- /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 00000000000..be937410cef
--- /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 7b2a27b9992..715dd79c97a 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/localTypes1.js b/tests/baselines/reference/localTypes1.js
new file mode 100644
index 00000000000..d1c3758920e
--- /dev/null
+++ b/tests/baselines/reference/localTypes1.js
@@ -0,0 +1,325 @@
+//// [localTypes1.ts]
+
+function f1() {
+    enum E {
+        A, B, C
+    }
+    class C {
+        x: E;
+    }
+    interface I {
+        x: E;
+    }
+    type A = I[];
+    let a: A = [new C()];
+    a[0].x = E.B;
+    return a;
+}
+
+function f2() {
+    function g() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        interface I {
+            x: E;
+        }
+        type A = I[];
+        let a: A = [new C()];
+        a[0].x = E.B;
+        return a;
+    }
+    return g();
+}
+
+function f3(b: boolean) {
+    if (true) {
+        enum E {
+            A, B, C
+        }
+        if (b) {
+            class C {
+                x: E;
+            }
+            interface I {
+                x: E;
+            }
+            type A = I[];
+            let a: A = [new C()];
+            a[0].x = E.B;
+            return a;
+        }
+        else {
+            class A {
+                x: E;
+            }
+            interface J {
+                x: E;
+            }
+            type C = J[];
+            let c: C = [new A()];
+            c[0].x = E.B;
+            return c;
+        }
+    }
+}
+
+function f5() {
+    var z1 = function () {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+    var z2 = () => {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+}
+
+class A {
+    constructor() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+    }
+    m() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+    get p() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+}
+
+function f6() {
+    class A {
+        a: string;
+    }
+    function g() {
+        class B extends A {
+            b: string;
+        }
+        function h() {
+            class C extends B {
+                c: string;
+            }
+            var x = new C();
+            x.a = "a";
+            x.b = "b";
+            x.c = "c";
+            return x;
+        }
+        return h();
+    }
+    return g();
+}
+
+
+//// [localTypes1.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+function f1() {
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+        E[E["B"] = 1] = "B";
+        E[E["C"] = 2] = "C";
+    })(E || (E = {}));
+    var C = (function () {
+        function C() {
+        }
+        return C;
+    })();
+    var a = [new C()];
+    a[0].x = E.B;
+    return a;
+}
+function f2() {
+    function g() {
+        var E;
+        (function (E) {
+            E[E["A"] = 0] = "A";
+            E[E["B"] = 1] = "B";
+            E[E["C"] = 2] = "C";
+        })(E || (E = {}));
+        var C = (function () {
+            function C() {
+            }
+            return C;
+        })();
+        var a = [new C()];
+        a[0].x = E.B;
+        return a;
+    }
+    return g();
+}
+function f3(b) {
+    if (true) {
+        var E;
+        (function (E) {
+            E[E["A"] = 0] = "A";
+            E[E["B"] = 1] = "B";
+            E[E["C"] = 2] = "C";
+        })(E || (E = {}));
+        if (b) {
+            var C = (function () {
+                function C() {
+                }
+                return C;
+            })();
+            var a = [new C()];
+            a[0].x = E.B;
+            return a;
+        }
+        else {
+            var A = (function () {
+                function A() {
+                }
+                return A;
+            })();
+            var c = [new A()];
+            c[0].x = E.B;
+            return c;
+        }
+    }
+}
+function f5() {
+    var z1 = function () {
+        var E;
+        (function (E) {
+            E[E["A"] = 0] = "A";
+            E[E["B"] = 1] = "B";
+            E[E["C"] = 2] = "C";
+        })(E || (E = {}));
+        var C = (function () {
+            function C() {
+            }
+            return C;
+        })();
+        return new C();
+    };
+    var z2 = function () {
+        var E;
+        (function (E) {
+            E[E["A"] = 0] = "A";
+            E[E["B"] = 1] = "B";
+            E[E["C"] = 2] = "C";
+        })(E || (E = {}));
+        var C = (function () {
+            function C() {
+            }
+            return C;
+        })();
+        return new C();
+    };
+}
+var A = (function () {
+    function A() {
+        var E;
+        (function (E) {
+            E[E["A"] = 0] = "A";
+            E[E["B"] = 1] = "B";
+            E[E["C"] = 2] = "C";
+        })(E || (E = {}));
+        var C = (function () {
+            function C() {
+            }
+            return C;
+        })();
+    }
+    A.prototype.m = function () {
+        var E;
+        (function (E) {
+            E[E["A"] = 0] = "A";
+            E[E["B"] = 1] = "B";
+            E[E["C"] = 2] = "C";
+        })(E || (E = {}));
+        var C = (function () {
+            function C() {
+            }
+            return C;
+        })();
+        return new C();
+    };
+    Object.defineProperty(A.prototype, "p", {
+        get: function () {
+            var E;
+            (function (E) {
+                E[E["A"] = 0] = "A";
+                E[E["B"] = 1] = "B";
+                E[E["C"] = 2] = "C";
+            })(E || (E = {}));
+            var C = (function () {
+                function C() {
+                }
+                return C;
+            })();
+            return new C();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return A;
+})();
+function f6() {
+    var A = (function () {
+        function A() {
+        }
+        return A;
+    })();
+    function g() {
+        var B = (function (_super) {
+            __extends(B, _super);
+            function B() {
+                _super.apply(this, arguments);
+            }
+            return B;
+        })(A);
+        function h() {
+            var C = (function (_super) {
+                __extends(C, _super);
+                function C() {
+                    _super.apply(this, arguments);
+                }
+                return C;
+            })(B);
+            var x = new C();
+            x.a = "a";
+            x.b = "b";
+            x.c = "c";
+            return x;
+        }
+        return h();
+    }
+    return g();
+}
diff --git a/tests/baselines/reference/localTypes1.symbols b/tests/baselines/reference/localTypes1.symbols
new file mode 100644
index 00000000000..53d4191ae61
--- /dev/null
+++ b/tests/baselines/reference/localTypes1.symbols
@@ -0,0 +1,357 @@
+=== tests/cases/conformance/types/localTypes/localTypes1.ts ===
+
+function f1() {
+>f1 : Symbol(f1, Decl(localTypes1.ts, 0, 0))
+
+    enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 1, 15))
+
+        A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 2, 12))
+>B : Symbol(E.B, Decl(localTypes1.ts, 3, 10))
+>C : Symbol(E.C, Decl(localTypes1.ts, 3, 13))
+    }
+    class C {
+>C : Symbol(C, Decl(localTypes1.ts, 4, 5))
+
+        x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 5, 13))
+>E : Symbol(E, Decl(localTypes1.ts, 1, 15))
+    }
+    interface I {
+>I : Symbol(I, Decl(localTypes1.ts, 7, 5))
+
+        x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 8, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 1, 15))
+    }
+    type A = I[];
+>A : Symbol(A, Decl(localTypes1.ts, 10, 5))
+>I : Symbol(I, Decl(localTypes1.ts, 7, 5))
+
+    let a: A = [new C()];
+>a : Symbol(a, Decl(localTypes1.ts, 12, 7))
+>A : Symbol(A, Decl(localTypes1.ts, 10, 5))
+>C : Symbol(C, Decl(localTypes1.ts, 4, 5))
+
+    a[0].x = E.B;
+>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 8, 17))
+>a : Symbol(a, Decl(localTypes1.ts, 12, 7))
+>x : Symbol(I.x, Decl(localTypes1.ts, 8, 17))
+>E.B : Symbol(E.B, Decl(localTypes1.ts, 3, 10))
+>E : Symbol(E, Decl(localTypes1.ts, 1, 15))
+>B : Symbol(E.B, Decl(localTypes1.ts, 3, 10))
+
+    return a;
+>a : Symbol(a, Decl(localTypes1.ts, 12, 7))
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(localTypes1.ts, 15, 1))
+
+    function g() {
+>g : Symbol(g, Decl(localTypes1.ts, 17, 15))
+
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 18, 18))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 19, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 20, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 20, 17))
+        }
+        class C {
+>C : Symbol(C, Decl(localTypes1.ts, 21, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 22, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 18, 18))
+        }
+        interface I {
+>I : Symbol(I, Decl(localTypes1.ts, 24, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 25, 21))
+>E : Symbol(E, Decl(localTypes1.ts, 18, 18))
+        }
+        type A = I[];
+>A : Symbol(A, Decl(localTypes1.ts, 27, 9))
+>I : Symbol(I, Decl(localTypes1.ts, 24, 9))
+
+        let a: A = [new C()];
+>a : Symbol(a, Decl(localTypes1.ts, 29, 11))
+>A : Symbol(A, Decl(localTypes1.ts, 27, 9))
+>C : Symbol(C, Decl(localTypes1.ts, 21, 9))
+
+        a[0].x = E.B;
+>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 25, 21))
+>a : Symbol(a, Decl(localTypes1.ts, 29, 11))
+>x : Symbol(I.x, Decl(localTypes1.ts, 25, 21))
+>E.B : Symbol(E.B, Decl(localTypes1.ts, 20, 14))
+>E : Symbol(E, Decl(localTypes1.ts, 18, 18))
+>B : Symbol(E.B, Decl(localTypes1.ts, 20, 14))
+
+        return a;
+>a : Symbol(a, Decl(localTypes1.ts, 29, 11))
+    }
+    return g();
+>g : Symbol(g, Decl(localTypes1.ts, 17, 15))
+}
+
+function f3(b: boolean) {
+>f3 : Symbol(f3, Decl(localTypes1.ts, 34, 1))
+>b : Symbol(b, Decl(localTypes1.ts, 36, 12))
+
+    if (true) {
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 38, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 39, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 39, 17))
+        }
+        if (b) {
+>b : Symbol(b, Decl(localTypes1.ts, 36, 12))
+
+            class C {
+>C : Symbol(C, Decl(localTypes1.ts, 41, 16))
+
+                x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 42, 21))
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+            }
+            interface I {
+>I : Symbol(I, Decl(localTypes1.ts, 44, 13))
+
+                x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 45, 25))
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+            }
+            type A = I[];
+>A : Symbol(A, Decl(localTypes1.ts, 47, 13))
+>I : Symbol(I, Decl(localTypes1.ts, 44, 13))
+
+            let a: A = [new C()];
+>a : Symbol(a, Decl(localTypes1.ts, 49, 15))
+>A : Symbol(A, Decl(localTypes1.ts, 47, 13))
+>C : Symbol(C, Decl(localTypes1.ts, 41, 16))
+
+            a[0].x = E.B;
+>a[0].x : Symbol(I.x, Decl(localTypes1.ts, 45, 25))
+>a : Symbol(a, Decl(localTypes1.ts, 49, 15))
+>x : Symbol(I.x, Decl(localTypes1.ts, 45, 25))
+>E.B : Symbol(E.B, Decl(localTypes1.ts, 39, 14))
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+>B : Symbol(E.B, Decl(localTypes1.ts, 39, 14))
+
+            return a;
+>a : Symbol(a, Decl(localTypes1.ts, 49, 15))
+        }
+        else {
+            class A {
+>A : Symbol(A, Decl(localTypes1.ts, 53, 14))
+
+                x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 54, 21))
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+            }
+            interface J {
+>J : Symbol(J, Decl(localTypes1.ts, 56, 13))
+
+                x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 57, 25))
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+            }
+            type C = J[];
+>C : Symbol(C, Decl(localTypes1.ts, 59, 13))
+>J : Symbol(J, Decl(localTypes1.ts, 56, 13))
+
+            let c: C = [new A()];
+>c : Symbol(c, Decl(localTypes1.ts, 61, 15))
+>C : Symbol(C, Decl(localTypes1.ts, 59, 13))
+>A : Symbol(A, Decl(localTypes1.ts, 53, 14))
+
+            c[0].x = E.B;
+>c[0].x : Symbol(J.x, Decl(localTypes1.ts, 57, 25))
+>c : Symbol(c, Decl(localTypes1.ts, 61, 15))
+>x : Symbol(J.x, Decl(localTypes1.ts, 57, 25))
+>E.B : Symbol(E.B, Decl(localTypes1.ts, 39, 14))
+>E : Symbol(E, Decl(localTypes1.ts, 37, 15))
+>B : Symbol(E.B, Decl(localTypes1.ts, 39, 14))
+
+            return c;
+>c : Symbol(c, Decl(localTypes1.ts, 61, 15))
+        }
+    }
+}
+
+function f5() {
+>f5 : Symbol(f5, Decl(localTypes1.ts, 66, 1))
+
+    var z1 = function () {
+>z1 : Symbol(z1, Decl(localTypes1.ts, 69, 7))
+
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 69, 26))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 70, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 71, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 71, 17))
+        }
+        class C {
+>C : Symbol(C, Decl(localTypes1.ts, 72, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 73, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 69, 26))
+        }
+        return new C();
+>C : Symbol(C, Decl(localTypes1.ts, 72, 9))
+    }
+    var z2 = () => {
+>z2 : Symbol(z2, Decl(localTypes1.ts, 78, 7))
+
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 78, 20))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 79, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 80, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 80, 17))
+        }
+        class C {
+>C : Symbol(C, Decl(localTypes1.ts, 81, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 82, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 78, 20))
+        }
+        return new C();
+>C : Symbol(C, Decl(localTypes1.ts, 81, 9))
+    }
+}
+
+class A {
+>A : Symbol(A, Decl(localTypes1.ts, 87, 1))
+
+    constructor() {
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 90, 19))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 91, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 92, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 92, 17))
+        }
+        class C {
+>C : Symbol(C, Decl(localTypes1.ts, 93, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 94, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 90, 19))
+        }
+    }
+    m() {
+>m : Symbol(m, Decl(localTypes1.ts, 97, 5))
+
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 98, 9))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 99, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 100, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 100, 17))
+        }
+        class C {
+>C : Symbol(C, Decl(localTypes1.ts, 101, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 102, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 98, 9))
+        }
+        return new C();
+>C : Symbol(C, Decl(localTypes1.ts, 101, 9))
+    }
+    get p() {
+>p : Symbol(p, Decl(localTypes1.ts, 106, 5))
+
+        enum E {
+>E : Symbol(E, Decl(localTypes1.ts, 107, 13))
+
+            A, B, C
+>A : Symbol(E.A, Decl(localTypes1.ts, 108, 16))
+>B : Symbol(E.B, Decl(localTypes1.ts, 109, 14))
+>C : Symbol(E.C, Decl(localTypes1.ts, 109, 17))
+        }
+        class C {
+>C : Symbol(C, Decl(localTypes1.ts, 110, 9))
+
+            x: E;
+>x : Symbol(x, Decl(localTypes1.ts, 111, 17))
+>E : Symbol(E, Decl(localTypes1.ts, 107, 13))
+        }
+        return new C();
+>C : Symbol(C, Decl(localTypes1.ts, 110, 9))
+    }
+}
+
+function f6() {
+>f6 : Symbol(f6, Decl(localTypes1.ts, 116, 1))
+
+    class A {
+>A : Symbol(A, Decl(localTypes1.ts, 118, 15))
+
+        a: string;
+>a : Symbol(a, Decl(localTypes1.ts, 119, 13))
+    }
+    function g() {
+>g : Symbol(g, Decl(localTypes1.ts, 121, 5))
+
+        class B extends A {
+>B : Symbol(B, Decl(localTypes1.ts, 122, 18))
+>A : Symbol(A, Decl(localTypes1.ts, 118, 15))
+
+            b: string;
+>b : Symbol(b, Decl(localTypes1.ts, 123, 27))
+        }
+        function h() {
+>h : Symbol(h, Decl(localTypes1.ts, 125, 9))
+
+            class C extends B {
+>C : Symbol(C, Decl(localTypes1.ts, 126, 22))
+>B : Symbol(B, Decl(localTypes1.ts, 122, 18))
+
+                c: string;
+>c : Symbol(c, Decl(localTypes1.ts, 127, 31))
+            }
+            var x = new C();
+>x : Symbol(x, Decl(localTypes1.ts, 130, 15))
+>C : Symbol(C, Decl(localTypes1.ts, 126, 22))
+
+            x.a = "a";
+>x.a : Symbol(A.a, Decl(localTypes1.ts, 119, 13))
+>x : Symbol(x, Decl(localTypes1.ts, 130, 15))
+>a : Symbol(A.a, Decl(localTypes1.ts, 119, 13))
+
+            x.b = "b";
+>x.b : Symbol(B.b, Decl(localTypes1.ts, 123, 27))
+>x : Symbol(x, Decl(localTypes1.ts, 130, 15))
+>b : Symbol(B.b, Decl(localTypes1.ts, 123, 27))
+
+            x.c = "c";
+>x.c : Symbol(C.c, Decl(localTypes1.ts, 127, 31))
+>x : Symbol(x, Decl(localTypes1.ts, 130, 15))
+>c : Symbol(C.c, Decl(localTypes1.ts, 127, 31))
+
+            return x;
+>x : Symbol(x, Decl(localTypes1.ts, 130, 15))
+        }
+        return h();
+>h : Symbol(h, Decl(localTypes1.ts, 125, 9))
+    }
+    return g();
+>g : Symbol(g, Decl(localTypes1.ts, 121, 5))
+}
+
diff --git a/tests/baselines/reference/localTypes1.types b/tests/baselines/reference/localTypes1.types
new file mode 100644
index 00000000000..1770a36edb7
--- /dev/null
+++ b/tests/baselines/reference/localTypes1.types
@@ -0,0 +1,395 @@
+=== tests/cases/conformance/types/localTypes/localTypes1.ts ===
+
+function f1() {
+>f1 : () => I[]
+
+    enum E {
+>E : E
+
+        A, B, C
+>A : E
+>B : E
+>C : E
+    }
+    class C {
+>C : C
+
+        x: E;
+>x : E
+>E : E
+    }
+    interface I {
+>I : I
+
+        x: E;
+>x : E
+>E : E
+    }
+    type A = I[];
+>A : I[]
+>I : I
+
+    let a: A = [new C()];
+>a : I[]
+>A : I[]
+>[new C()] : C[]
+>new C() : C
+>C : typeof C
+
+    a[0].x = E.B;
+>a[0].x = E.B : E
+>a[0].x : E
+>a[0] : I
+>a : I[]
+>0 : number
+>x : E
+>E.B : E
+>E : typeof E
+>B : E
+
+    return a;
+>a : I[]
+}
+
+function f2() {
+>f2 : () => I[]
+
+    function g() {
+>g : () => I[]
+
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        class C {
+>C : C
+
+            x: E;
+>x : E
+>E : E
+        }
+        interface I {
+>I : I
+
+            x: E;
+>x : E
+>E : E
+        }
+        type A = I[];
+>A : I[]
+>I : I
+
+        let a: A = [new C()];
+>a : I[]
+>A : I[]
+>[new C()] : C[]
+>new C() : C
+>C : typeof C
+
+        a[0].x = E.B;
+>a[0].x = E.B : E
+>a[0].x : E
+>a[0] : I
+>a : I[]
+>0 : number
+>x : E
+>E.B : E
+>E : typeof E
+>B : E
+
+        return a;
+>a : I[]
+    }
+    return g();
+>g() : I[]
+>g : () => I[]
+}
+
+function f3(b: boolean) {
+>f3 : (b: boolean) => I[]
+>b : boolean
+
+    if (true) {
+>true : boolean
+
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        if (b) {
+>b : boolean
+
+            class C {
+>C : C
+
+                x: E;
+>x : E
+>E : E
+            }
+            interface I {
+>I : I
+
+                x: E;
+>x : E
+>E : E
+            }
+            type A = I[];
+>A : I[]
+>I : I
+
+            let a: A = [new C()];
+>a : I[]
+>A : I[]
+>[new C()] : C[]
+>new C() : C
+>C : typeof C
+
+            a[0].x = E.B;
+>a[0].x = E.B : E
+>a[0].x : E
+>a[0] : I
+>a : I[]
+>0 : number
+>x : E
+>E.B : E
+>E : typeof E
+>B : E
+
+            return a;
+>a : I[]
+        }
+        else {
+            class A {
+>A : A
+
+                x: E;
+>x : E
+>E : E
+            }
+            interface J {
+>J : J
+
+                x: E;
+>x : E
+>E : E
+            }
+            type C = J[];
+>C : J[]
+>J : J
+
+            let c: C = [new A()];
+>c : J[]
+>C : J[]
+>[new A()] : A[]
+>new A() : A
+>A : typeof A
+
+            c[0].x = E.B;
+>c[0].x = E.B : E
+>c[0].x : E
+>c[0] : J
+>c : J[]
+>0 : number
+>x : E
+>E.B : E
+>E : typeof E
+>B : E
+
+            return c;
+>c : J[]
+        }
+    }
+}
+
+function f5() {
+>f5 : () => void
+
+    var z1 = function () {
+>z1 : () => C
+>function () {        enum E {            A, B, C        }        class C {            x: E;        }        return new C();    } : () => C
+
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        class C {
+>C : C
+
+            x: E;
+>x : E
+>E : E
+        }
+        return new C();
+>new C() : C
+>C : typeof C
+    }
+    var z2 = () => {
+>z2 : () => C
+>() => {        enum E {            A, B, C        }        class C {            x: E;        }        return new C();    } : () => C
+
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        class C {
+>C : C
+
+            x: E;
+>x : E
+>E : E
+        }
+        return new C();
+>new C() : C
+>C : typeof C
+    }
+}
+
+class A {
+>A : A
+
+    constructor() {
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        class C {
+>C : C
+
+            x: E;
+>x : E
+>E : E
+        }
+    }
+    m() {
+>m : () => C
+
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        class C {
+>C : C
+
+            x: E;
+>x : E
+>E : E
+        }
+        return new C();
+>new C() : C
+>C : typeof C
+    }
+    get p() {
+>p : C
+
+        enum E {
+>E : E
+
+            A, B, C
+>A : E
+>B : E
+>C : E
+        }
+        class C {
+>C : C
+
+            x: E;
+>x : E
+>E : E
+        }
+        return new C();
+>new C() : C
+>C : typeof C
+    }
+}
+
+function f6() {
+>f6 : () => C
+
+    class A {
+>A : A
+
+        a: string;
+>a : string
+    }
+    function g() {
+>g : () => C
+
+        class B extends A {
+>B : B
+>A : A
+
+            b: string;
+>b : string
+        }
+        function h() {
+>h : () => C
+
+            class C extends B {
+>C : C
+>B : B
+
+                c: string;
+>c : string
+            }
+            var x = new C();
+>x : C
+>new C() : C
+>C : typeof C
+
+            x.a = "a";
+>x.a = "a" : string
+>x.a : string
+>x : C
+>a : string
+>"a" : string
+
+            x.b = "b";
+>x.b = "b" : string
+>x.b : string
+>x : C
+>b : string
+>"b" : string
+
+            x.c = "c";
+>x.c = "c" : string
+>x.c : string
+>x : C
+>c : string
+>"c" : string
+
+            return x;
+>x : C
+        }
+        return h();
+>h() : C
+>h : () => C
+    }
+    return g();
+>g() : C
+>g : () => C
+}
+
diff --git a/tests/baselines/reference/localTypes2.js b/tests/baselines/reference/localTypes2.js
new file mode 100644
index 00000000000..a95844f0794
--- /dev/null
+++ b/tests/baselines/reference/localTypes2.js
@@ -0,0 +1,92 @@
+//// [localTypes2.ts]
+function f1() {
+    function f() {
+        class C {
+            constructor(public x: number, public y: number) { }
+        }
+        return C;
+    }
+    let C = f();
+    let v = new C(10, 20);
+    let x = v.x;
+    let y = v.y;
+}
+
+function f2() {
+    function f(x: number) {
+        class C {
+            public x = x;
+            constructor(public y: number) { }
+        }
+        return C;
+    }
+    let C = f(10);
+    let v = new C(20);
+    let x = v.x;
+    let y = v.y;
+}
+
+function f3() {
+    function f(x: number, y: number) {
+        class C {
+            public x = x;
+            public y = y;
+        }
+        return C;
+    }
+    let C = f(10, 20);
+    let v = new C();
+    let x = v.x;
+    let y = v.y;
+}
+
+
+//// [localTypes2.js]
+function f1() {
+    function f() {
+        var C = (function () {
+            function C(x, y) {
+                this.x = x;
+                this.y = y;
+            }
+            return C;
+        })();
+        return C;
+    }
+    var C = f();
+    var v = new C(10, 20);
+    var x = v.x;
+    var y = v.y;
+}
+function f2() {
+    function f(x) {
+        var C = (function () {
+            function C(y) {
+                this.y = y;
+                this.x = x;
+            }
+            return C;
+        })();
+        return C;
+    }
+    var C = f(10);
+    var v = new C(20);
+    var x = v.x;
+    var y = v.y;
+}
+function f3() {
+    function f(x, y) {
+        var C = (function () {
+            function C() {
+                this.x = x;
+                this.y = y;
+            }
+            return C;
+        })();
+        return C;
+    }
+    var C = f(10, 20);
+    var v = new C();
+    var x = v.x;
+    var y = v.y;
+}
diff --git a/tests/baselines/reference/localTypes2.symbols b/tests/baselines/reference/localTypes2.symbols
new file mode 100644
index 00000000000..3054c6f552d
--- /dev/null
+++ b/tests/baselines/reference/localTypes2.symbols
@@ -0,0 +1,122 @@
+=== tests/cases/conformance/types/localTypes/localTypes2.ts ===
+function f1() {
+>f1 : Symbol(f1, Decl(localTypes2.ts, 0, 0))
+
+    function f() {
+>f : Symbol(f, Decl(localTypes2.ts, 0, 15))
+
+        class C {
+>C : Symbol(C, Decl(localTypes2.ts, 1, 18))
+
+            constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(localTypes2.ts, 3, 24))
+>y : Symbol(y, Decl(localTypes2.ts, 3, 41))
+        }
+        return C;
+>C : Symbol(C, Decl(localTypes2.ts, 1, 18))
+    }
+    let C = f();
+>C : Symbol(C, Decl(localTypes2.ts, 7, 7))
+>f : Symbol(f, Decl(localTypes2.ts, 0, 15))
+
+    let v = new C(10, 20);
+>v : Symbol(v, Decl(localTypes2.ts, 8, 7))
+>C : Symbol(C, Decl(localTypes2.ts, 7, 7))
+
+    let x = v.x;
+>x : Symbol(x, Decl(localTypes2.ts, 9, 7))
+>v.x : Symbol(C.x, Decl(localTypes2.ts, 3, 24))
+>v : Symbol(v, Decl(localTypes2.ts, 8, 7))
+>x : Symbol(C.x, Decl(localTypes2.ts, 3, 24))
+
+    let y = v.y;
+>y : Symbol(y, Decl(localTypes2.ts, 10, 7))
+>v.y : Symbol(C.y, Decl(localTypes2.ts, 3, 41))
+>v : Symbol(v, Decl(localTypes2.ts, 8, 7))
+>y : Symbol(C.y, Decl(localTypes2.ts, 3, 41))
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(localTypes2.ts, 11, 1))
+
+    function f(x: number) {
+>f : Symbol(f, Decl(localTypes2.ts, 13, 15))
+>x : Symbol(x, Decl(localTypes2.ts, 14, 15))
+
+        class C {
+>C : Symbol(C, Decl(localTypes2.ts, 14, 27))
+
+            public x = x;
+>x : Symbol(x, Decl(localTypes2.ts, 15, 17))
+>x : Symbol(x, Decl(localTypes2.ts, 14, 15))
+
+            constructor(public y: number) { }
+>y : Symbol(y, Decl(localTypes2.ts, 17, 24))
+        }
+        return C;
+>C : Symbol(C, Decl(localTypes2.ts, 14, 27))
+    }
+    let C = f(10);
+>C : Symbol(C, Decl(localTypes2.ts, 21, 7))
+>f : Symbol(f, Decl(localTypes2.ts, 13, 15))
+
+    let v = new C(20);
+>v : Symbol(v, Decl(localTypes2.ts, 22, 7))
+>C : Symbol(C, Decl(localTypes2.ts, 21, 7))
+
+    let x = v.x;
+>x : Symbol(x, Decl(localTypes2.ts, 23, 7))
+>v.x : Symbol(C.x, Decl(localTypes2.ts, 15, 17))
+>v : Symbol(v, Decl(localTypes2.ts, 22, 7))
+>x : Symbol(C.x, Decl(localTypes2.ts, 15, 17))
+
+    let y = v.y;
+>y : Symbol(y, Decl(localTypes2.ts, 24, 7))
+>v.y : Symbol(C.y, Decl(localTypes2.ts, 17, 24))
+>v : Symbol(v, Decl(localTypes2.ts, 22, 7))
+>y : Symbol(C.y, Decl(localTypes2.ts, 17, 24))
+}
+
+function f3() {
+>f3 : Symbol(f3, Decl(localTypes2.ts, 25, 1))
+
+    function f(x: number, y: number) {
+>f : Symbol(f, Decl(localTypes2.ts, 27, 15))
+>x : Symbol(x, Decl(localTypes2.ts, 28, 15))
+>y : Symbol(y, Decl(localTypes2.ts, 28, 25))
+
+        class C {
+>C : Symbol(C, Decl(localTypes2.ts, 28, 38))
+
+            public x = x;
+>x : Symbol(x, Decl(localTypes2.ts, 29, 17))
+>x : Symbol(x, Decl(localTypes2.ts, 28, 15))
+
+            public y = y;
+>y : Symbol(y, Decl(localTypes2.ts, 30, 25))
+>y : Symbol(y, Decl(localTypes2.ts, 28, 25))
+        }
+        return C;
+>C : Symbol(C, Decl(localTypes2.ts, 28, 38))
+    }
+    let C = f(10, 20);
+>C : Symbol(C, Decl(localTypes2.ts, 35, 7))
+>f : Symbol(f, Decl(localTypes2.ts, 27, 15))
+
+    let v = new C();
+>v : Symbol(v, Decl(localTypes2.ts, 36, 7))
+>C : Symbol(C, Decl(localTypes2.ts, 35, 7))
+
+    let x = v.x;
+>x : Symbol(x, Decl(localTypes2.ts, 37, 7))
+>v.x : Symbol(C.x, Decl(localTypes2.ts, 29, 17))
+>v : Symbol(v, Decl(localTypes2.ts, 36, 7))
+>x : Symbol(C.x, Decl(localTypes2.ts, 29, 17))
+
+    let y = v.y;
+>y : Symbol(y, Decl(localTypes2.ts, 38, 7))
+>v.y : Symbol(C.y, Decl(localTypes2.ts, 30, 25))
+>v : Symbol(v, Decl(localTypes2.ts, 36, 7))
+>y : Symbol(C.y, Decl(localTypes2.ts, 30, 25))
+}
+
diff --git a/tests/baselines/reference/localTypes2.types b/tests/baselines/reference/localTypes2.types
new file mode 100644
index 00000000000..a6b85b7bb14
--- /dev/null
+++ b/tests/baselines/reference/localTypes2.types
@@ -0,0 +1,134 @@
+=== tests/cases/conformance/types/localTypes/localTypes2.ts ===
+function f1() {
+>f1 : () => void
+
+    function f() {
+>f : () => typeof C
+
+        class C {
+>C : C
+
+            constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+        }
+        return C;
+>C : typeof C
+    }
+    let C = f();
+>C : typeof C
+>f() : typeof C
+>f : () => typeof C
+
+    let v = new C(10, 20);
+>v : C
+>new C(10, 20) : C
+>C : typeof C
+>10 : number
+>20 : number
+
+    let x = v.x;
+>x : number
+>v.x : number
+>v : C
+>x : number
+
+    let y = v.y;
+>y : number
+>v.y : number
+>v : C
+>y : number
+}
+
+function f2() {
+>f2 : () => void
+
+    function f(x: number) {
+>f : (x: number) => typeof C
+>x : number
+
+        class C {
+>C : C
+
+            public x = x;
+>x : number
+>x : number
+
+            constructor(public y: number) { }
+>y : number
+        }
+        return C;
+>C : typeof C
+    }
+    let C = f(10);
+>C : typeof C
+>f(10) : typeof C
+>f : (x: number) => typeof C
+>10 : number
+
+    let v = new C(20);
+>v : C
+>new C(20) : C
+>C : typeof C
+>20 : number
+
+    let x = v.x;
+>x : number
+>v.x : number
+>v : C
+>x : number
+
+    let y = v.y;
+>y : number
+>v.y : number
+>v : C
+>y : number
+}
+
+function f3() {
+>f3 : () => void
+
+    function f(x: number, y: number) {
+>f : (x: number, y: number) => typeof C
+>x : number
+>y : number
+
+        class C {
+>C : C
+
+            public x = x;
+>x : number
+>x : number
+
+            public y = y;
+>y : number
+>y : number
+        }
+        return C;
+>C : typeof C
+    }
+    let C = f(10, 20);
+>C : typeof C
+>f(10, 20) : typeof C
+>f : (x: number, y: number) => typeof C
+>10 : number
+>20 : number
+
+    let v = new C();
+>v : C
+>new C() : C
+>C : typeof C
+
+    let x = v.x;
+>x : number
+>v.x : number
+>v : C
+>x : number
+
+    let y = v.y;
+>y : number
+>v.y : number
+>v : C
+>y : number
+}
+
diff --git a/tests/baselines/reference/localTypes3.js b/tests/baselines/reference/localTypes3.js
new file mode 100644
index 00000000000..2d40bc922b9
--- /dev/null
+++ b/tests/baselines/reference/localTypes3.js
@@ -0,0 +1,92 @@
+//// [localTypes3.ts]
+function f1() {
+    function f() {
+        class C<X, Y> {
+            constructor(public x: X, public y: Y) { }
+        }
+        return C;
+    }
+    let C = f();
+    let v = new C(10, "hello");
+    let x = v.x;
+    let y = v.y;
+}
+
+function f2() {
+    function f<X>(x: X) {
+        class C<Y> {
+            public x = x;
+            constructor(public y: Y) { }
+        }
+        return C;
+    }
+    let C = f(10);
+    let v = new C("hello");
+    let x = v.x;
+    let y = v.y;
+}
+
+function f3() {
+    function f<X, Y>(x: X, y: Y) {
+        class C {
+            public x = x;
+            public y = y;
+        }
+        return C;
+    }
+    let C = f(10, "hello");
+    let v = new C();
+    let x = v.x;
+    let y = v.y;
+}
+
+
+//// [localTypes3.js]
+function f1() {
+    function f() {
+        var C = (function () {
+            function C(x, y) {
+                this.x = x;
+                this.y = y;
+            }
+            return C;
+        })();
+        return C;
+    }
+    var C = f();
+    var v = new C(10, "hello");
+    var x = v.x;
+    var y = v.y;
+}
+function f2() {
+    function f(x) {
+        var C = (function () {
+            function C(y) {
+                this.y = y;
+                this.x = x;
+            }
+            return C;
+        })();
+        return C;
+    }
+    var C = f(10);
+    var v = new C("hello");
+    var x = v.x;
+    var y = v.y;
+}
+function f3() {
+    function f(x, y) {
+        var C = (function () {
+            function C() {
+                this.x = x;
+                this.y = y;
+            }
+            return C;
+        })();
+        return C;
+    }
+    var C = f(10, "hello");
+    var v = new C();
+    var x = v.x;
+    var y = v.y;
+}
diff --git a/tests/baselines/reference/localTypes3.symbols b/tests/baselines/reference/localTypes3.symbols
new file mode 100644
index 00000000000..fe7082e4577
--- /dev/null
+++ b/tests/baselines/reference/localTypes3.symbols
@@ -0,0 +1,134 @@
+=== tests/cases/conformance/types/localTypes/localTypes3.ts ===
+function f1() {
+>f1 : Symbol(f1, Decl(localTypes3.ts, 0, 0))
+
+    function f() {
+>f : Symbol(f, Decl(localTypes3.ts, 0, 15))
+
+        class C<X, Y> {
+>C : Symbol(C, Decl(localTypes3.ts, 1, 18))
+>X : Symbol(X, Decl(localTypes3.ts, 2, 16))
+>Y : Symbol(Y, Decl(localTypes3.ts, 2, 18))
+
+            constructor(public x: X, public y: Y) { }
+>x : Symbol(x, Decl(localTypes3.ts, 3, 24))
+>X : Symbol(X, Decl(localTypes3.ts, 2, 16))
+>y : Symbol(y, Decl(localTypes3.ts, 3, 36))
+>Y : Symbol(Y, Decl(localTypes3.ts, 2, 18))
+        }
+        return C;
+>C : Symbol(C, Decl(localTypes3.ts, 1, 18))
+    }
+    let C = f();
+>C : Symbol(C, Decl(localTypes3.ts, 7, 7))
+>f : Symbol(f, Decl(localTypes3.ts, 0, 15))
+
+    let v = new C(10, "hello");
+>v : Symbol(v, Decl(localTypes3.ts, 8, 7))
+>C : Symbol(C, Decl(localTypes3.ts, 7, 7))
+
+    let x = v.x;
+>x : Symbol(x, Decl(localTypes3.ts, 9, 7))
+>v.x : Symbol(C.x, Decl(localTypes3.ts, 3, 24))
+>v : Symbol(v, Decl(localTypes3.ts, 8, 7))
+>x : Symbol(C.x, Decl(localTypes3.ts, 3, 24))
+
+    let y = v.y;
+>y : Symbol(y, Decl(localTypes3.ts, 10, 7))
+>v.y : Symbol(C.y, Decl(localTypes3.ts, 3, 36))
+>v : Symbol(v, Decl(localTypes3.ts, 8, 7))
+>y : Symbol(C.y, Decl(localTypes3.ts, 3, 36))
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(localTypes3.ts, 11, 1))
+
+    function f<X>(x: X) {
+>f : Symbol(f, Decl(localTypes3.ts, 13, 15))
+>X : Symbol(X, Decl(localTypes3.ts, 14, 15))
+>x : Symbol(x, Decl(localTypes3.ts, 14, 18))
+>X : Symbol(X, Decl(localTypes3.ts, 14, 15))
+
+        class C<Y> {
+>C : Symbol(C, Decl(localTypes3.ts, 14, 25))
+>Y : Symbol(Y, Decl(localTypes3.ts, 15, 16))
+
+            public x = x;
+>x : Symbol(x, Decl(localTypes3.ts, 15, 20))
+>x : Symbol(x, Decl(localTypes3.ts, 14, 18))
+
+            constructor(public y: Y) { }
+>y : Symbol(y, Decl(localTypes3.ts, 17, 24))
+>Y : Symbol(Y, Decl(localTypes3.ts, 15, 16))
+        }
+        return C;
+>C : Symbol(C, Decl(localTypes3.ts, 14, 25))
+    }
+    let C = f(10);
+>C : Symbol(C, Decl(localTypes3.ts, 21, 7))
+>f : Symbol(f, Decl(localTypes3.ts, 13, 15))
+
+    let v = new C("hello");
+>v : Symbol(v, Decl(localTypes3.ts, 22, 7))
+>C : Symbol(C, Decl(localTypes3.ts, 21, 7))
+
+    let x = v.x;
+>x : Symbol(x, Decl(localTypes3.ts, 23, 7))
+>v.x : Symbol(C.x, Decl(localTypes3.ts, 15, 20))
+>v : Symbol(v, Decl(localTypes3.ts, 22, 7))
+>x : Symbol(C.x, Decl(localTypes3.ts, 15, 20))
+
+    let y = v.y;
+>y : Symbol(y, Decl(localTypes3.ts, 24, 7))
+>v.y : Symbol(C.y, Decl(localTypes3.ts, 17, 24))
+>v : Symbol(v, Decl(localTypes3.ts, 22, 7))
+>y : Symbol(C.y, Decl(localTypes3.ts, 17, 24))
+}
+
+function f3() {
+>f3 : Symbol(f3, Decl(localTypes3.ts, 25, 1))
+
+    function f<X, Y>(x: X, y: Y) {
+>f : Symbol(f, Decl(localTypes3.ts, 27, 15))
+>X : Symbol(X, Decl(localTypes3.ts, 28, 15))
+>Y : Symbol(Y, Decl(localTypes3.ts, 28, 17))
+>x : Symbol(x, Decl(localTypes3.ts, 28, 21))
+>X : Symbol(X, Decl(localTypes3.ts, 28, 15))
+>y : Symbol(y, Decl(localTypes3.ts, 28, 26))
+>Y : Symbol(Y, Decl(localTypes3.ts, 28, 17))
+
+        class C {
+>C : Symbol(C, Decl(localTypes3.ts, 28, 34))
+
+            public x = x;
+>x : Symbol(x, Decl(localTypes3.ts, 29, 17))
+>x : Symbol(x, Decl(localTypes3.ts, 28, 21))
+
+            public y = y;
+>y : Symbol(y, Decl(localTypes3.ts, 30, 25))
+>y : Symbol(y, Decl(localTypes3.ts, 28, 26))
+        }
+        return C;
+>C : Symbol(C, Decl(localTypes3.ts, 28, 34))
+    }
+    let C = f(10, "hello");
+>C : Symbol(C, Decl(localTypes3.ts, 35, 7))
+>f : Symbol(f, Decl(localTypes3.ts, 27, 15))
+
+    let v = new C();
+>v : Symbol(v, Decl(localTypes3.ts, 36, 7))
+>C : Symbol(C, Decl(localTypes3.ts, 35, 7))
+
+    let x = v.x;
+>x : Symbol(x, Decl(localTypes3.ts, 37, 7))
+>v.x : Symbol(C.x, Decl(localTypes3.ts, 29, 17))
+>v : Symbol(v, Decl(localTypes3.ts, 36, 7))
+>x : Symbol(C.x, Decl(localTypes3.ts, 29, 17))
+
+    let y = v.y;
+>y : Symbol(y, Decl(localTypes3.ts, 38, 7))
+>v.y : Symbol(C.y, Decl(localTypes3.ts, 30, 25))
+>v : Symbol(v, Decl(localTypes3.ts, 36, 7))
+>y : Symbol(C.y, Decl(localTypes3.ts, 30, 25))
+}
+
diff --git a/tests/baselines/reference/localTypes3.types b/tests/baselines/reference/localTypes3.types
new file mode 100644
index 00000000000..551096468c5
--- /dev/null
+++ b/tests/baselines/reference/localTypes3.types
@@ -0,0 +1,146 @@
+=== tests/cases/conformance/types/localTypes/localTypes3.ts ===
+function f1() {
+>f1 : () => void
+
+    function f() {
+>f : () => typeof C
+
+        class C<X, Y> {
+>C : C<X, Y>
+>X : X
+>Y : Y
+
+            constructor(public x: X, public y: Y) { }
+>x : X
+>X : X
+>y : Y
+>Y : Y
+        }
+        return C;
+>C : typeof C
+    }
+    let C = f();
+>C : typeof C
+>f() : typeof C
+>f : () => typeof C
+
+    let v = new C(10, "hello");
+>v : C<number, string>
+>new C(10, "hello") : C<number, string>
+>C : typeof C
+>10 : number
+>"hello" : string
+
+    let x = v.x;
+>x : number
+>v.x : number
+>v : C<number, string>
+>x : number
+
+    let y = v.y;
+>y : string
+>v.y : string
+>v : C<number, string>
+>y : string
+}
+
+function f2() {
+>f2 : () => void
+
+    function f<X>(x: X) {
+>f : <X>(x: X) => typeof C
+>X : X
+>x : X
+>X : X
+
+        class C<Y> {
+>C : C<Y>
+>Y : Y
+
+            public x = x;
+>x : X
+>x : X
+
+            constructor(public y: Y) { }
+>y : Y
+>Y : Y
+        }
+        return C;
+>C : typeof C
+    }
+    let C = f(10);
+>C : typeof C
+>f(10) : typeof C
+>f : <X>(x: X) => typeof C
+>10 : number
+
+    let v = new C("hello");
+>v : f<number>.C<string>
+>new C("hello") : f<number>.C<string>
+>C : typeof C
+>"hello" : string
+
+    let x = v.x;
+>x : number
+>v.x : number
+>v : f<number>.C<string>
+>x : number
+
+    let y = v.y;
+>y : string
+>v.y : string
+>v : f<number>.C<string>
+>y : string
+}
+
+function f3() {
+>f3 : () => void
+
+    function f<X, Y>(x: X, y: Y) {
+>f : <X, Y>(x: X, y: Y) => typeof C
+>X : X
+>Y : Y
+>x : X
+>X : X
+>y : Y
+>Y : Y
+
+        class C {
+>C : C
+
+            public x = x;
+>x : X
+>x : X
+
+            public y = y;
+>y : Y
+>y : Y
+        }
+        return C;
+>C : typeof C
+    }
+    let C = f(10, "hello");
+>C : typeof C
+>f(10, "hello") : typeof C
+>f : <X, Y>(x: X, y: Y) => typeof C
+>10 : number
+>"hello" : string
+
+    let v = new C();
+>v : f<number, string>.C
+>new C() : f<number, string>.C
+>C : typeof C
+
+    let x = v.x;
+>x : number
+>v.x : number
+>v : f<number, string>.C
+>x : number
+
+    let y = v.y;
+>y : string
+>v.y : string
+>v : f<number, string>.C
+>y : string
+}
+
diff --git a/tests/baselines/reference/localTypes4.errors.txt b/tests/baselines/reference/localTypes4.errors.txt
new file mode 100644
index 00000000000..cad9d30c933
--- /dev/null
+++ b/tests/baselines/reference/localTypes4.errors.txt
@@ -0,0 +1,53 @@
+tests/cases/conformance/types/localTypes/localTypes4.ts(10,19): error TS2304: Cannot find name 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(10,23): error TS2304: Cannot find name 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(18,16): error TS2300: Duplicate identifier 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(19,19): error TS2300: Duplicate identifier 'T'.
+
+
+==== tests/cases/conformance/types/localTypes/localTypes4.ts (4 errors) ====
+    function f1() {
+        // Type parameters are in scope in parameters and return types
+        function f<T>(x: T): T {
+            return undefined;
+        }
+    }
+    
+    function f2() {
+        // Local types are not in scope in parameters and return types
+        function f(x: T): T {
+                      ~
+!!! error TS2304: Cannot find name 'T'.
+                          ~
+!!! error TS2304: Cannot find name 'T'.
+            interface T { }
+            return undefined;
+        }
+    }
+    
+    function f3() {
+        // Type parameters and top-level local types are in same declaration space
+        function f<T>() {
+                   ~
+!!! error TS2300: Duplicate identifier 'T'.
+            interface T { }
+                      ~
+!!! error TS2300: Duplicate identifier 'T'.
+            return undefined;
+        }
+    }
+    
+    function f4() {
+        // Local types are block scoped
+        interface T { x: number }
+        let v: T;
+        v.x = 10;
+        if (true) {
+            interface T { x: string }
+            let v: T;
+            v.x = "hello";
+        }
+        else {
+            v.x = 20;
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/localTypes4.js b/tests/baselines/reference/localTypes4.js
new file mode 100644
index 00000000000..8f51761a65a
--- /dev/null
+++ b/tests/baselines/reference/localTypes4.js
@@ -0,0 +1,70 @@
+//// [localTypes4.ts]
+function f1() {
+    // Type parameters are in scope in parameters and return types
+    function f<T>(x: T): T {
+        return undefined;
+    }
+}
+
+function f2() {
+    // Local types are not in scope in parameters and return types
+    function f(x: T): T {
+        interface T { }
+        return undefined;
+    }
+}
+
+function f3() {
+    // Type parameters and top-level local types are in same declaration space
+    function f<T>() {
+        interface T { }
+        return undefined;
+    }
+}
+
+function f4() {
+    // Local types are block scoped
+    interface T { x: number }
+    let v: T;
+    v.x = 10;
+    if (true) {
+        interface T { x: string }
+        let v: T;
+        v.x = "hello";
+    }
+    else {
+        v.x = 20;
+    }
+}
+
+
+//// [localTypes4.js]
+function f1() {
+    // Type parameters are in scope in parameters and return types
+    function f(x) {
+        return undefined;
+    }
+}
+function f2() {
+    // Local types are not in scope in parameters and return types
+    function f(x) {
+        return undefined;
+    }
+}
+function f3() {
+    // Type parameters and top-level local types are in same declaration space
+    function f() {
+        return undefined;
+    }
+}
+function f4() {
+    var v;
+    v.x = 10;
+    if (true) {
+        var v_1;
+        v_1.x = "hello";
+    }
+    else {
+        v.x = 20;
+    }
+}
diff --git a/tests/baselines/reference/localTypes5.js b/tests/baselines/reference/localTypes5.js
new file mode 100644
index 00000000000..872629276d2
--- /dev/null
+++ b/tests/baselines/reference/localTypes5.js
@@ -0,0 +1,38 @@
+//// [localTypes5.ts]
+function foo<A>() {
+    class X {
+        m<B, C>() {
+            return (function <D>() {
+                class Y<E> {
+                }
+                return new Y<string>();
+            })<Date>();
+        }
+    }
+    var x = new X();
+    return x.m<number, boolean>();
+}
+var x = foo<void>();
+
+
+//// [localTypes5.js]
+function foo() {
+    var X = (function () {
+        function X() {
+        }
+        X.prototype.m = function () {
+            return (function () {
+                var Y = (function () {
+                    function Y() {
+                    }
+                    return Y;
+                })();
+                return new Y();
+            })();
+        };
+        return X;
+    })();
+    var x = new X();
+    return x.m();
+}
+var x = foo();
diff --git a/tests/baselines/reference/localTypes5.symbols b/tests/baselines/reference/localTypes5.symbols
new file mode 100644
index 00000000000..4ffe53b3e53
--- /dev/null
+++ b/tests/baselines/reference/localTypes5.symbols
@@ -0,0 +1,40 @@
+=== tests/cases/conformance/types/localTypes/localTypes5.ts ===
+function foo<A>() {
+>foo : Symbol(foo, Decl(localTypes5.ts, 0, 0))
+>A : Symbol(A, Decl(localTypes5.ts, 0, 13))
+
+    class X {
+>X : Symbol(X, Decl(localTypes5.ts, 0, 19))
+
+        m<B, C>() {
+>m : Symbol(m, Decl(localTypes5.ts, 1, 13))
+>B : Symbol(B, Decl(localTypes5.ts, 2, 10))
+>C : Symbol(C, Decl(localTypes5.ts, 2, 12))
+
+            return (function <D>() {
+>D : Symbol(D, Decl(localTypes5.ts, 3, 30))
+
+                class Y<E> {
+>Y : Symbol(Y, Decl(localTypes5.ts, 3, 36))
+>E : Symbol(E, Decl(localTypes5.ts, 4, 24))
+                }
+                return new Y<string>();
+>Y : Symbol(Y, Decl(localTypes5.ts, 3, 36))
+
+            })<Date>();
+>Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+        }
+    }
+    var x = new X();
+>x : Symbol(x, Decl(localTypes5.ts, 10, 7))
+>X : Symbol(X, Decl(localTypes5.ts, 0, 19))
+
+    return x.m<number, boolean>();
+>x.m : Symbol(X.m, Decl(localTypes5.ts, 1, 13))
+>x : Symbol(x, Decl(localTypes5.ts, 10, 7))
+>m : Symbol(X.m, Decl(localTypes5.ts, 1, 13))
+}
+var x = foo<void>();
+>x : Symbol(x, Decl(localTypes5.ts, 13, 3))
+>foo : Symbol(foo, Decl(localTypes5.ts, 0, 0))
+
diff --git a/tests/baselines/reference/localTypes5.types b/tests/baselines/reference/localTypes5.types
new file mode 100644
index 00000000000..b12e362f754
--- /dev/null
+++ b/tests/baselines/reference/localTypes5.types
@@ -0,0 +1,47 @@
+=== tests/cases/conformance/types/localTypes/localTypes5.ts ===
+function foo<A>() {
+>foo : <A>() => X.m<number, boolean>.<Date>.Y<string>
+>A : A
+
+    class X {
+>X : X
+
+        m<B, C>() {
+>m : <B, C>() => <Date>.Y<string>
+>B : B
+>C : C
+
+            return (function <D>() {
+>(function <D>() {                class Y<E> {                }                return new Y<string>();            })<Date>() : <Date>.Y<string>
+>(function <D>() {                class Y<E> {                }                return new Y<string>();            }) : <D>() => Y<string>
+>function <D>() {                class Y<E> {                }                return new Y<string>();            } : <D>() => Y<string>
+>D : D
+
+                class Y<E> {
+>Y : Y<E>
+>E : E
+                }
+                return new Y<string>();
+>new Y<string>() : Y<string>
+>Y : typeof Y
+
+            })<Date>();
+>Date : Date
+        }
+    }
+    var x = new X();
+>x : X
+>new X() : X
+>X : typeof X
+
+    return x.m<number, boolean>();
+>x.m<number, boolean>() : X.m<number, boolean>.<Date>.Y<string>
+>x.m : <B, C>() => <Date>.Y<string>
+>x : X
+>m : <B, C>() => <Date>.Y<string>
+}
+var x = foo<void>();
+>x : foo<void>.X.m<number, boolean>.<Date>.Y<string>
+>foo<void>() : foo<void>.X.m<number, boolean>.<Date>.Y<string>
+>foo : <A>() => X.m<number, boolean>.<Date>.Y<string>
+
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 615de521b83..9a6e2ef47ba 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 7b28cf64ae9..e6eef0a1840 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 46ca3c74b95..00000000000
--- 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 00000000000..4248d66fb42
--- /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 00000000000..3a6f5d16726
--- /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 c4015c3492d..4ea9d0283a9 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/withStatementErrors.errors.txt b/tests/baselines/reference/withStatementErrors.errors.txt
index ba399f51197..bfea39b5426 100644
--- a/tests/baselines/reference/withStatementErrors.errors.txt
+++ b/tests/baselines/reference/withStatementErrors.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/withStatementErrors.ts(3,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/withStatementErrors.ts(13,5): error TS1129: Statement expected.
+tests/cases/compiler/withStatementErrors.ts(15,5): error TS1129: Statement expected.
 tests/cases/compiler/withStatementErrors.ts(17,1): error TS1128: Declaration or statement expected.
 
 
@@ -19,10 +19,10 @@ tests/cases/compiler/withStatementErrors.ts(17,1): error TS1128: Declaration or
         class C {} // error   
         
         interface I {} // error
-        ~~~~~~~~~
-!!! error TS1129: Statement expected.
         
         module M {} // error
+        ~~~~~~
+!!! error TS1129: Statement expected.
             
     }
     ~
diff --git a/tests/baselines/reference/withStatementErrors.js b/tests/baselines/reference/withStatementErrors.js
index 43236c94d8d..65b45999463 100644
--- a/tests/baselines/reference/withStatementErrors.js
+++ b/tests/baselines/reference/withStatementErrors.js
@@ -28,5 +28,5 @@ with (ooo.eee.oo.ah_ah.ting.tang.walla.walla) {
         function C() {
         }
         return C;
-    })();
-} // error   
+    })(); // error   
+} // error
diff --git a/tests/baselines/reference/yieldExpression1.errors.txt b/tests/baselines/reference/yieldExpression1.errors.txt
index 91a379e6172..22bd6387b3f 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 00000000000..85b66f92192
--- /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 00000000000..dee3db70c24
--- /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 00000000000..d0b2a172433
--- /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 00000000000..9a618df4bd0
--- /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 00000000000..3384d609c16
--- /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 00000000000..4e652232e6a
--- /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 00000000000..b4a3108fe34
--- /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 00000000000..f4d560c521f
--- /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 00000000000..b4a3108fe34
--- /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 00000000000..f4d560c521f
--- /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 00000000000..559b5e8dacb
--- /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 00000000000..fb7c358f189
--- /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 00000000000..c21ecea7826
--- /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 00000000000..de362aedc8b
--- /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 00000000000..6f482573241
--- /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 00000000000..7342a49a366
--- /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 00000000000..1efa9af0839
--- /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 00000000000..c01d7f5340f
--- /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 00000000000..813ea07075d
--- /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 00000000000..e77ec3d911c
--- /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 00000000000..6f602a23981
--- /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 00000000000..a21d9e8ab63
--- /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 00000000000..74761b14772
--- /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 00000000000..b810a13aa55
--- /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 00000000000..06d3de394ef
--- /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 00000000000..15d760b7949
--- /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 00000000000..d63e69d1b86
--- /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 00000000000..e9b2cc29b27
--- /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 00000000000..b66b3aab356
--- /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 00000000000..5cb029205da
--- /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 00000000000..991f082141e
--- /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 00000000000..0359ba3c4c9
--- /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 00000000000..20c98e9e7e7
--- /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 00000000000..9b383d8a02a
--- /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 00000000000..9a942f174ae
--- /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 00000000000..334d21e3833
--- /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 00000000000..f501aa407f8
--- /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 00000000000..7a190e5bd45
--- /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 00000000000..be99cf02441
--- /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 00000000000..9b0e6f5ef59
--- /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 00000000000..be99cf02441
--- /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 00000000000..f4082f7b46f
--- /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 00000000000..f975eefa841
--- /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 00000000000..4bb94263831
--- /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 00000000000..3afd5617a08
--- /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 00000000000..9adab4c0ed9
--- /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 00000000000..e304dda4828
--- /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 00000000000..f9fe46f4285
--- /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 00000000000..03bb28ef0ec
--- /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 00000000000..b578f8f2399
--- /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 00000000000..160aee0d709
--- /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 00000000000..2dee3dedf02
--- /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 00000000000..caa4eed0747
--- /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 00000000000..4fe9ddced96
--- /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 00000000000..e2b72f4b790
--- /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 00000000000..e7146fa6915
--- /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 00000000000..ce0822da412
--- /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 00000000000..53c5c7131db
--- /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 00000000000..6eb9fa74a6e
--- /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 00000000000..65885f28a5b
--- /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 00000000000..956704d8a4c
--- /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 00000000000..c1b659604ba
--- /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 00000000000..1261d4b268b
--- /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 00000000000..be88b9b99aa
--- /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 00000000000..4e985dca921
--- /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 00000000000..9c75afe9ef1
--- /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 00000000000..b5f47f76b3d
--- /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 00000000000..2041764a2f9
--- /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 00000000000..7aa66480a16
--- /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 00000000000..f972a2a60e3
--- /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 00000000000..081979be505
--- /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 00000000000..81aacecd7a3
--- /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 00000000000..8f61f87db83
--- /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 00000000000..36747936f17
--- /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 00000000000..31c36e2a626
--- /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 00000000000..59e9b489d5f
--- /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 00000000000..659406ee999
--- /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 00000000000..f4386c70feb
--- /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/conformance/types/localTypes/localTypes1.ts b/tests/cases/conformance/types/localTypes/localTypes1.ts
new file mode 100644
index 00000000000..bceb9ad32cf
--- /dev/null
+++ b/tests/cases/conformance/types/localTypes/localTypes1.ts
@@ -0,0 +1,141 @@
+// @target: es5
+
+function f1() {
+    enum E {
+        A, B, C
+    }
+    class C {
+        x: E;
+    }
+    interface I {
+        x: E;
+    }
+    type A = I[];
+    let a: A = [new C()];
+    a[0].x = E.B;
+    return a;
+}
+
+function f2() {
+    function g() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        interface I {
+            x: E;
+        }
+        type A = I[];
+        let a: A = [new C()];
+        a[0].x = E.B;
+        return a;
+    }
+    return g();
+}
+
+function f3(b: boolean) {
+    if (true) {
+        enum E {
+            A, B, C
+        }
+        if (b) {
+            class C {
+                x: E;
+            }
+            interface I {
+                x: E;
+            }
+            type A = I[];
+            let a: A = [new C()];
+            a[0].x = E.B;
+            return a;
+        }
+        else {
+            class A {
+                x: E;
+            }
+            interface J {
+                x: E;
+            }
+            type C = J[];
+            let c: C = [new A()];
+            c[0].x = E.B;
+            return c;
+        }
+    }
+}
+
+function f5() {
+    var z1 = function () {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+    var z2 = () => {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+}
+
+class A {
+    constructor() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+    }
+    m() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+    get p() {
+        enum E {
+            A, B, C
+        }
+        class C {
+            x: E;
+        }
+        return new C();
+    }
+}
+
+function f6() {
+    class A {
+        a: string;
+    }
+    function g() {
+        class B extends A {
+            b: string;
+        }
+        function h() {
+            class C extends B {
+                c: string;
+            }
+            var x = new C();
+            x.a = "a";
+            x.b = "b";
+            x.c = "c";
+            return x;
+        }
+        return h();
+    }
+    return g();
+}
diff --git a/tests/cases/conformance/types/localTypes/localTypes2.ts b/tests/cases/conformance/types/localTypes/localTypes2.ts
new file mode 100644
index 00000000000..79f1402c702
--- /dev/null
+++ b/tests/cases/conformance/types/localTypes/localTypes2.ts
@@ -0,0 +1,40 @@
+function f1() {
+    function f() {
+        class C {
+            constructor(public x: number, public y: number) { }
+        }
+        return C;
+    }
+    let C = f();
+    let v = new C(10, 20);
+    let x = v.x;
+    let y = v.y;
+}
+
+function f2() {
+    function f(x: number) {
+        class C {
+            public x = x;
+            constructor(public y: number) { }
+        }
+        return C;
+    }
+    let C = f(10);
+    let v = new C(20);
+    let x = v.x;
+    let y = v.y;
+}
+
+function f3() {
+    function f(x: number, y: number) {
+        class C {
+            public x = x;
+            public y = y;
+        }
+        return C;
+    }
+    let C = f(10, 20);
+    let v = new C();
+    let x = v.x;
+    let y = v.y;
+}
diff --git a/tests/cases/conformance/types/localTypes/localTypes3.ts b/tests/cases/conformance/types/localTypes/localTypes3.ts
new file mode 100644
index 00000000000..5eb3cf28506
--- /dev/null
+++ b/tests/cases/conformance/types/localTypes/localTypes3.ts
@@ -0,0 +1,40 @@
+function f1() {
+    function f() {
+        class C<X, Y> {
+            constructor(public x: X, public y: Y) { }
+        }
+        return C;
+    }
+    let C = f();
+    let v = new C(10, "hello");
+    let x = v.x;
+    let y = v.y;
+}
+
+function f2() {
+    function f<X>(x: X) {
+        class C<Y> {
+            public x = x;
+            constructor(public y: Y) { }
+        }
+        return C;
+    }
+    let C = f(10);
+    let v = new C("hello");
+    let x = v.x;
+    let y = v.y;
+}
+
+function f3() {
+    function f<X, Y>(x: X, y: Y) {
+        class C {
+            public x = x;
+            public y = y;
+        }
+        return C;
+    }
+    let C = f(10, "hello");
+    let v = new C();
+    let x = v.x;
+    let y = v.y;
+}
diff --git a/tests/cases/conformance/types/localTypes/localTypes4.ts b/tests/cases/conformance/types/localTypes/localTypes4.ts
new file mode 100644
index 00000000000..bd31e76a80f
--- /dev/null
+++ b/tests/cases/conformance/types/localTypes/localTypes4.ts
@@ -0,0 +1,37 @@
+function f1() {
+    // Type parameters are in scope in parameters and return types
+    function f<T>(x: T): T {
+        return undefined;
+    }
+}
+
+function f2() {
+    // Local types are not in scope in parameters and return types
+    function f(x: T): T {
+        interface T { }
+        return undefined;
+    }
+}
+
+function f3() {
+    // Type parameters and top-level local types are in same declaration space
+    function f<T>() {
+        interface T { }
+        return undefined;
+    }
+}
+
+function f4() {
+    // Local types are block scoped
+    interface T { x: number }
+    let v: T;
+    v.x = 10;
+    if (true) {
+        interface T { x: string }
+        let v: T;
+        v.x = "hello";
+    }
+    else {
+        v.x = 20;
+    }
+}
diff --git a/tests/cases/conformance/types/localTypes/localTypes5.ts b/tests/cases/conformance/types/localTypes/localTypes5.ts
new file mode 100644
index 00000000000..6aec24f183d
--- /dev/null
+++ b/tests/cases/conformance/types/localTypes/localTypes5.ts
@@ -0,0 +1,14 @@
+function foo<A>() {
+    class X {
+        m<B, C>() {
+            return (function <D>() {
+                class Y<E> {
+                }
+                return new Y<string>();
+            })<Date>();
+        }
+    }
+    var x = new X();
+    return x.m<number, boolean>();
+}
+var x = foo<void>();
diff --git a/tests/cases/fourslash/generatorDeclarationFormatting.ts b/tests/cases/fourslash/generatorDeclarationFormatting.ts
new file mode 100644
index 00000000000..007380fd0de
--- /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/getJavaScriptSyntacticDiagnostics1.ts b/tests/cases/fourslash/getJavaScriptSyntacticDiagnostics1.ts
index 372ae8d6e2e..3e7c3d0ca85 100644
--- a/tests/cases/fourslash/getJavaScriptSyntacticDiagnostics1.ts
+++ b/tests/cases/fourslash/getJavaScriptSyntacticDiagnostics1.ts
@@ -14,6 +14,6 @@ verify.getSyntacticDiagnostics(`[
     "start": 26,
     "length": 4,
     "category": "error",
-    "code": 1219
+    "code": 1222
   }
 ]`);
\ 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 00000000000..8ea5d86673e
--- /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]);
+}