diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 20033d4c80b..c86906ca5b6 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -423,6 +423,13 @@ module ts {
             if (!links.target) {
                 links.target = resolvingSymbol;
                 var node = <ImportDeclaration>getDeclarationOfKind(symbol, SyntaxKind.ImportDeclaration);
+                // Grammar checking
+                if (node.moduleReference.kind === SyntaxKind.ExternalModuleReference) {
+                    if ((<ExternalModuleReference>node.moduleReference).expression.kind !== SyntaxKind.StringLiteral) {
+                        grammarErrorOnNode((<ExternalModuleReference>node.moduleReference).expression, Diagnostics.String_literal_expected);
+                    }
+                }
+
                 var target = node.moduleReference.kind === SyntaxKind.ExternalModuleReference
                     ? resolveExternalModuleName(node, getExternalModuleImportDeclarationExpression(node))
                     : getSymbolOfPartOfRightHandSideOfImport(<EntityName>node.moduleReference, node);
@@ -5338,10 +5345,14 @@ module ts {
         }
 
         function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type {
+            // Grammar checking
+            checkGrammarObjectLiteralExpression(node);
+
             var members = node.symbol.members;
             var properties: SymbolTable = {};
             var contextualType = getContextualType(node);
             var typeFlags: TypeFlags;
+
             for (var id in members) {
                 if (hasProperty(members, id)) {
                     var member = members[id];
@@ -5390,6 +5401,7 @@ module ts {
                     properties[member.name] = member;
                 }
             }
+
             var stringIndexType = getIndexType(IndexKind.String);
             var numberIndexType = getIndexType(IndexKind.Number);
             var result = createAnonymousType(node.symbol, properties, emptyArray, emptyArray, stringIndexType, numberIndexType);
@@ -5531,6 +5543,21 @@ module ts {
         }
 
         function checkIndexedAccess(node: ElementAccessExpression): Type {
+            // Grammar checking
+            if (!node.argumentExpression) {
+                var sourceFile = getSourceFile(node);
+                if (node.parent.kind === SyntaxKind.NewExpression && (<NewExpression>node.parent).expression === node) {
+                    var start = skipTrivia(sourceFile.text, node.expression.end);
+                    var end = node.end;
+                    grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
+                }
+                else {
+                    var start = node.end - "]".length;
+                    var end = node.end;
+                    grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Expression_expected);
+                }
+            }
+
             // Obtain base constraint such that we can bail out if the constraint is an unknown type
             var objectType = getApparentType(checkExpression(node.expression));
             var indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType;
@@ -6233,6 +6260,9 @@ module ts {
         }
 
         function checkCallExpression(node: CallExpression): Type {
+            // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true
+            checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);
+
             var signature = getResolvedSignature(node);
             if (node.expression.kind === SyntaxKind.SuperKeyword) {
                 return voidType;
@@ -6255,6 +6285,11 @@ module ts {
         }
 
         function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
+            // Grammar checking
+            if (compilerOptions.target < ScriptTarget.ES6) {
+                grammarErrorOnFirstToken(node.template, Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher);
+            }
+
             return getReturnTypeOfSignature(getResolvedSignature(node));
         }
 
@@ -6382,6 +6417,12 @@ module ts {
         function checkFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | MethodDeclaration, contextualMapper?: TypeMapper): Type {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
 
+            // Grammar checking
+            var hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
+            if (!hasGrammarError && node.kind === SyntaxKind.FunctionExpression) {
+                checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node);
+            }
+
             // The identityMapper object is used to indicate that function expressions are wildcards
             if (contextualMapper === identityMapper) {
                 return anyFunctionType;
@@ -6523,6 +6564,13 @@ module ts {
         }
 
         function checkDeleteExpression(node: DeleteExpression): Type {
+            // Grammar checking
+            if (node.parserContextFlags & ParserContextFlags.StrictMode && node.expression.kind === SyntaxKind.Identifier) {
+                // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its
+                // UnaryExpression is a direct reference to a variable, function argument, or function name
+                grammarErrorOnNode(node.expression, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode);
+            }
+
             var operandType = checkExpression(node.expression);
             return booleanType;
         }
@@ -6538,6 +6586,14 @@ module ts {
         }
 
         function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type {
+            // Grammar checking
+            // The identifier eval or arguments may not appear as the LeftHandSideExpression of an
+            // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression
+            // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator
+            if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken)) {
+                checkGrammarEvalOrArgumentsInStrictMode(node, <Identifier>node.operand);
+            }
+
             var operandType = checkExpression(node.operand);
             switch (node.operator) {
                 case SyntaxKind.PlusToken:
@@ -6561,6 +6617,12 @@ module ts {
         }
 
         function checkPostfixUnaryExpression(node: PostfixUnaryExpression): Type {
+            // Grammar checking
+            // The identifier eval or arguments may not appear as the LeftHandSideExpression of an
+            // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression
+            // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator.
+            checkGrammarEvalOrArgumentsInStrictMode(node, <Identifier>node.operand);
+
             var operandType = checkExpression(node.operand);
             var ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
             if (ok) {
@@ -6687,6 +6749,13 @@ module ts {
         }
 
         function checkBinaryExpression(node: BinaryExpression, contextualMapper?: TypeMapper) {
+            // Grammar checking
+            if (isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operator)) {
+                // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an
+                // Assignment operator(11.13) or of a PostfixExpression(11.3)
+                checkGrammarEvalOrArgumentsInStrictMode(node, <Identifier>node.left);
+            }
+
             var operator = node.operator;
             if (operator === SyntaxKind.EqualsToken && (node.left.kind === SyntaxKind.ObjectLiteralExpression || node.left.kind === SyntaxKind.ArrayLiteralExpression)) {
                 return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper);
@@ -6841,6 +6910,16 @@ module ts {
             }
         }
 
+        function checkYieldExpression(node: YieldExpression): void {
+            // Grammar checking
+            if (!(node.parserContextFlags & ParserContextFlags.Yield)) {
+                grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration);
+            }
+            else {
+                grammarErrorOnFirstToken(node, Diagnostics.yield_expressions_are_not_currently_supported);
+            }
+        }
+
         function checkConditionalExpression(node: ConditionalExpression, contextualMapper?: TypeMapper): Type {
             checkExpression(node.condition);
             var type1 = checkExpression(node.whenTrue, contextualMapper);
@@ -6878,6 +6957,9 @@ module ts {
         }
 
         function checkObjectLiteralMethod(node: MethodDeclaration, contextualMapper?: TypeMapper): Type {
+            // Grammar checking
+            checkGrammarMethod(node);
+
             var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper);
             return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper);
         }
@@ -6937,6 +7019,12 @@ module ts {
             return type;
         }
 
+        function checkNumericLiteral(node: LiteralExpression): Type {
+            // Grammar checking
+            checkGrammarNumbericLiteral(node);
+            return numberType;
+        }
+
         function checkExpressionWorker(node: Expression, contextualMapper: TypeMapper): Type {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
@@ -6951,7 +7039,7 @@ module ts {
                 case SyntaxKind.FalseKeyword:
                     return booleanType;
                 case SyntaxKind.NumericLiteral:
-                    return numberType;
+                    return checkNumericLiteral(<LiteralExpression>node);
                 case SyntaxKind.TemplateExpression:
                     return checkTemplateExpression(<TemplateExpression>node);
                 case SyntaxKind.StringLiteral:
@@ -6995,6 +7083,9 @@ module ts {
                     return checkConditionalExpression(<ConditionalExpression>node, contextualMapper);
                 case SyntaxKind.OmittedExpression:
                     return undefinedType;
+                case SyntaxKind.YieldExpression:
+                    checkYieldExpression(<YieldExpression>node);
+                    return unknownType;
             }
             return unknownType;
         }
@@ -7002,6 +7093,11 @@ module ts {
         // DECLARATION AND STATEMENT TYPE CHECKING
 
         function checkTypeParameter(node: TypeParameterDeclaration) {
+            // Grammar Checking
+            if (node.expression) {
+                grammarErrorOnFirstToken(node.expression, Diagnostics.Type_expected);
+            }
+
             checkSourceElement(node.constraint);
             if (fullTypeCheck) {
                 checkTypeParameterHasIllegalReferencesInConstraint(node);
@@ -7011,6 +7107,16 @@ module ts {
         }
 
         function checkParameter(node: ParameterDeclaration) {
+            // Grammar checking
+            // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the
+            // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code
+            // or if its FunctionBody is strict code(11.1.5).
+            // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a
+            // strict mode FunctionLikeDeclaration or FunctionExpression(13.1)
+
+            // Grammar checking
+            checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, <Identifier>node.name);
+
             checkVariableLikeDeclaration(node);
             var func = getContainingFunction(node);
             if (node.flags & (NodeFlags.Public | NodeFlags.Private | NodeFlags.Protected)) {
@@ -7027,6 +7133,17 @@ module ts {
         }
 
         function checkSignatureDeclaration(node: SignatureDeclaration) {
+            // Grammar checking
+            if (node.kind === SyntaxKind.IndexSignature) {
+                checkGrammarIndexSignature(<SignatureDeclaration>node);
+            }
+            // TODO (yuisu): Remove this check in else-if when SyntaxKind.Construct is moved and ambient context is handled
+            else  if (node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.ConstructorType ||
+                      node.kind === SyntaxKind.CallSignature || node.kind === SyntaxKind.Constructor ||
+                      node.kind === SyntaxKind.ConstructSignature){
+                checkGrammarFunctionLikeDeclaration(<FunctionLikeDeclaration>node);
+            }
+
             checkTypeParameters(node.typeParameters);
             forEach(node.parameters, checkParameter);
             if (node.type) {
@@ -7093,15 +7210,26 @@ module ts {
         }
 
         function checkPropertyDeclaration(node: PropertyDeclaration) {
+            // Grammar checking
+            checkGrammarModifiers(node) || checkGrammarProperty(node);
+
             checkVariableLikeDeclaration(node);
         }
 
         function checkMethodDeclaration(node: MethodDeclaration) {
+            // Grammar checking
+            checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name);
+
+            // Grammar checking for modifiers is done inside the function checkGrammarFunctionLikeDeclaration
             checkFunctionLikeDeclaration(node);
         }
 
         function checkConstructorDeclaration(node: ConstructorDeclaration) {
+            // Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function.
             checkSignatureDeclaration(node);
+            // Grammar check for checking only related to constructoDeclaration
+            checkGrammarConstructorTypeParameters(node) || checkGrammarConstructorTypeAnnotation(node);
+
             checkSourceElement(node.body);
 
             var symbol = getSymbolOfNode(node);
@@ -7184,6 +7312,9 @@ module ts {
         }
 
         function checkAccessorDeclaration(node: AccessorDeclaration) {
+            // Grammar checking accessors
+            checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
+
             if (fullTypeCheck) {
                 if (node.kind === SyntaxKind.GetAccessor) {
                     if (!isInAmbientContext(node) && node.body && !(bodyContainsAReturnStatement(<Block>node.body) || bodyContainsSingleThrowStatement(<Block>node.body))) {
@@ -7220,6 +7351,9 @@ module ts {
         }
 
         function checkTypeReference(node: TypeReferenceNode) {
+            // Grammar checking
+            checkGrammarTypeArguments(node, node.typeArguments);
+
             var type = getTypeFromTypeReferenceNode(node);
             if (type !== unknownType && node.typeArguments) {
                 // Do type argument local checks only if referenced type is successfully resolved
@@ -7253,6 +7387,12 @@ module ts {
         }
 
         function checkTupleType(node: TupleTypeNode) {
+            // Grammar checking
+            var hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes);
+            if (!hasErrorFromDisallowedTrailingComma && node.elementTypes.length === 0) {
+                grammarErrorOnNode(node, Diagnostics.A_tuple_type_element_list_cannot_be_empty);
+            }
+
             forEach(node.elementTypes, checkSourceElement);
         }
 
@@ -7605,7 +7745,11 @@ module ts {
         }
 
         function checkFunctionDeclaration(node: FunctionDeclaration): void {
+            // Grammar Checking, check signature of function declaration as checkFunctionLikeDeclaration call checkGarmmarFunctionLikeDeclaration
             checkFunctionLikeDeclaration(node);
+            //Grammar check other component of the functionDeclaration
+            checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node);
+
             if (fullTypeCheck) {
                 checkCollisionWithCapturedSuperVariable(node, node.name);
                 checkCollisionWithCapturedThisVariable(node, node.name);
@@ -7651,6 +7795,11 @@ module ts {
         }
 
         function checkBlock(node: Block) {
+            // Grammar checking for SyntaxKind.Block
+            if (node.kind === SyntaxKind.Block) {
+                checkGrammarForStatementInAmbientContext(node);
+            }
+
             forEach(node.statements, checkSourceElement);
             if (isFunctionBlock(node) || node.kind === SyntaxKind.ModuleBlock) {
                 checkFunctionExpressionBodies(node);
@@ -7838,6 +7987,15 @@ module ts {
 
         // Check variable, parameter, or property declaration
         function checkVariableLikeDeclaration(node: VariableLikeDeclaration) {
+            // Grammar checking
+            // TODO (yuisu) : Revisit this check once move all grammar checking
+            if (node.kind === SyntaxKind.BindingElement) {
+                checkGrammarEvalOrArgumentsInStrictMode(node, <Identifier>node.name);
+            }
+            else if (node.kind === SyntaxKind.VariableDeclaration) {
+                checkGrammarVariableDeclaration(<VariableDeclaration>node);
+            }
+
             checkSourceElement(node.type);
             // For a computed property, just check the initializer and exit
             if (hasComputedNameButNotSymbol(node)) {
@@ -7894,30 +8052,48 @@ module ts {
         }
 
         function checkVariableStatement(node: VariableStatement) {
+            // Grammar checking
+            checkGrammarModifiers(node) || checkGrammarVariableDeclarations(node, node.declarations) || checkGrammarForDisallowedLetOrConstStatement(node);
+
             forEach(node.declarations, checkSourceElement);
         }
 
         function checkExpressionStatement(node: ExpressionStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node)
+
             checkExpression(node.expression);
         }
 
         function checkIfStatement(node: IfStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node);
+
             checkExpression(node.expression);
             checkSourceElement(node.thenStatement);
             checkSourceElement(node.elseStatement);
         }
 
         function checkDoStatement(node: DoStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node);
+
             checkSourceElement(node.statement);
             checkExpression(node.expression);
         }
 
         function checkWhileStatement(node: WhileStatement) {
+            // Grammar checking 
+            checkGrammarForStatementInAmbientContext(node);
+
             checkExpression(node.expression);
             checkSourceElement(node.statement);
         }
 
         function checkForStatement(node: ForStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node) || checkGrammarVariableDeclarations(node, node.declarations);
+
             if (node.declarations) forEach(<VariableLikeDeclaration[]>node.declarations, checkVariableLikeDeclaration);
             if (node.initializer) checkExpression(node.initializer);
             if (node.condition) checkExpression(node.condition);
@@ -7926,6 +8102,15 @@ module ts {
         }
 
         function checkForInStatement(node: ForInStatement) {
+            // Grammar checking 
+            if (!checkGrammarForStatementInAmbientContext(node)) {
+                var declarations = node.declarations;
+                if (!checkGrammarVariableDeclarations(node, declarations)) {
+                    if (declarations && declarations.length > 1) {
+                        grammarErrorOnFirstToken(declarations[1], Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement);
+                    }
+                }
+            }
 
             // TypeScript 1.0 spec  (April 2014): 5.4
             // In a 'for-in' statement of the form
@@ -7968,6 +8153,9 @@ module ts {
         }
 
         function checkBreakOrContinueStatement(node: BreakOrContinueStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node);
+
             // TODO: Check that target label is valid
         }
 
@@ -7976,6 +8164,14 @@ module ts {
         }
 
         function checkReturnStatement(node: ReturnStatement) {
+            // Grammar checking
+            if (!checkGrammarForStatementInAmbientContext(node)) {
+                var functionBlock = getContainingFunction(node);
+                if (!functionBlock) {
+                    grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
+                }
+            }
+
             if (node.expression) {
                 var func = getContainingFunction(node);
                 if (func) {
@@ -7999,13 +8195,40 @@ module ts {
         }
 
         function checkWithStatement(node: WithStatement) {
+            // Grammar checking for withStatement
+            if (!checkGrammarForStatementInAmbientContext(node)) {
+                if (node.parserContextFlags & ParserContextFlags.StrictMode) {
+                    grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                }
+            }
+
             checkExpression(node.expression);
             error(node.expression, Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any);
         }
 
         function checkSwitchStatement(node: SwitchStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node);
+
+            var firstDefaultClause: CaseOrDefaultClause;
+            var hasDuplicateDefaultClause = false;
+
             var expressionType = checkExpression(node.expression);
             forEach(node.clauses, clause => {
+                // Grammar check for duplicate default clauses, skip if we already report duplicate default clause
+                if (clause.kind === SyntaxKind.DefaultClause && !hasDuplicateDefaultClause) {
+                    if (firstDefaultClause === undefined) {
+                        firstDefaultClause = clause;
+                    }
+                    else {
+                        var sourceFile = getSourceFileOfNode(node);
+                        var start = skipTrivia(sourceFile.text, clause.pos);
+                        var end = clause.statements.length > 0 ? clause.statements[0].pos : clause.end;
+                        grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
+                        hasDuplicateDefaultClause = true;
+                    }
+                }
+
                 if (fullTypeCheck && clause.kind === SyntaxKind.CaseClause) {
                     var caseClause = <CaseClause>clause;
                     // TypeScript 1.0 spec (April 2014):5.9
@@ -8021,18 +8244,58 @@ module ts {
         }
 
         function checkLabeledStatement(node: LabeledStatement) {
+            // Grammar checking
+            if (!checkGrammarForStatementInAmbientContext(node)) {
+                var current = node.parent;
+                while (current) {
+                    if (isAnyFunction(current)) {
+                        break;
+                    }
+                    if (current.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>current).label.text === node.label.text) {
+                        var sourceFile = getSourceFileOfNode(node);
+                        grammarErrorOnNode(node.label, Diagnostics.Duplicate_label_0, getTextOfNodeFromSourceText(sourceFile.text, node.label));
+                        break;
+                    }
+                    current = current.parent;
+                }
+            }
+
+            // ensure that label is unique
             checkSourceElement(node.statement);
         }
 
         function checkThrowStatement(node: ThrowStatement) {
+            // Grammar checking
+            if (!checkGrammarForStatementInAmbientContext(node)) {
+                if (node.expression === undefined) {
+                    grammarErrorAfterFirstToken(node, Diagnostics.Line_break_not_permitted_here);
+                }
+            }
+
             if (node.expression) {
                 checkExpression(node.expression);
             }
         }
 
         function checkTryStatement(node: TryStatement) {
+            // Grammar checking
+            checkGrammarForStatementInAmbientContext(node);
+
             checkBlock(node.tryBlock);
-            if (node.catchClause) checkBlock(node.catchClause.block);
+            var catchClause = node.catchClause;
+            if (catchClause) {
+                // Grammar checking
+                if (catchClause.type) {
+                    var sourceFile = getSourceFileOfNode(node);
+                    var colonStart = skipTrivia(sourceFile.text, catchClause.name.end);
+                    grammarErrorAtPos(sourceFile, colonStart, ":".length, Diagnostics.Catch_clause_parameter_cannot_have_a_type_annotation);
+                }
+                // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the
+                // Catch production is eval or arguments
+                checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.name);
+
+                checkBlock(catchClause.block);
+            }
             if (node.finallyBlock) checkBlock(node.finallyBlock);
         }
 
@@ -8138,6 +8401,9 @@ module ts {
         }
 
         function checkClassDeclaration(node: ClassDeclaration) {
+            // Grammar checking
+            checkGrammarClassDeclarationHeritageClauses(node);
+
             checkTypeNameIsReserved(node.name, Diagnostics.Class_name_cannot_be_0);
             checkTypeParameters(node.typeParameters);
             checkCollisionWithCapturedThisVariable(node, node.name);
@@ -8341,6 +8607,9 @@ module ts {
         }
 
         function checkInterfaceDeclaration(node: InterfaceDeclaration) {
+            // Grammar checking
+            checkGrammarModifiers(node) || checkGrammarInterfaceDeclaration(node);
+
             checkTypeParameters(node.typeParameters);
             if (fullTypeCheck) {
                 checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);
@@ -8375,6 +8644,9 @@ module ts {
         }
 
         function checkTypeAliasDeclaration(node: TypeAliasDeclaration) {
+            // Grammar checking
+            checkGrammarModifiers(node);
+            
             checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
             checkSourceElement(node.type);
         }
@@ -8538,6 +8810,9 @@ module ts {
         }
 
         function checkEnumDeclaration(node: EnumDeclaration) {
+            // Grammar checking
+            checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node);
+
             if (!fullTypeCheck) {
                 return;
             }
@@ -8605,6 +8880,27 @@ module ts {
         }
 
         function checkModuleDeclaration(node: ModuleDeclaration) {
+            // Grammar checking
+            if (!checkGrammarModifiers(node)) {
+                if (!isInAmbientContext(node) && node.name.kind === SyntaxKind.StringLiteral) {
+                    grammarErrorOnNode(node.name, Diagnostics.Only_ambient_modules_can_use_quoted_names);
+                }
+                else if (node.name.kind === SyntaxKind.Identifier && node.body.kind === SyntaxKind.ModuleBlock) {
+                    var statements = (<ModuleBlock>node.body).statements;
+                    for (var i = 0, n = statements.length; i < n; i++) {
+                        var statement = statements[i];
+
+                        if (statement.kind === SyntaxKind.ExportAssignment) {
+                            // Export assignments are not allowed in an internal module
+                            grammarErrorOnNode(statement, Diagnostics.An_export_assignment_cannot_be_used_in_an_internal_module);
+                        }
+                        else if (isExternalModuleImportDeclaration(statement)) {
+                            grammarErrorOnNode(getExternalModuleImportDeclarationExpression(statement), Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module);
+                        }
+                    }
+                }
+            }
+
             if (fullTypeCheck) {
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
@@ -8641,6 +8937,9 @@ module ts {
         }
 
         function checkImportDeclaration(node: ImportDeclaration) {
+            // Grammar checking
+            checkGrammarModifiers(node);
+
             checkCollisionWithCapturedThisVariable(node, node.name);
             checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
             var symbol = getSymbolOfNode(node);
@@ -8706,6 +9005,11 @@ module ts {
         }
 
         function checkExportAssignment(node: ExportAssignment) {
+            // Grammar checking
+            if (!checkGrammarModifiers(node) && (node.flags & NodeFlags.Modifier)) {
+                grammarErrorOnFirstToken(node, Diagnostics.An_export_assignment_cannot_have_modifiers);
+            }
+
             var container = node.parent;
             if (container.kind !== SyntaxKind.SourceFile) {
                 // In a module, the immediate parent will be a block, so climb up one more parent
@@ -8728,6 +9032,7 @@ module ts {
                 case SyntaxKind.ConstructorType:
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.ConstructSignature:
+                    return checkSignatureDeclaration(<SignatureDeclaration>node);
                 case SyntaxKind.IndexSignature:
                     return checkSignatureDeclaration(<SignatureDeclaration>node);
                 case SyntaxKind.MethodDeclaration:
@@ -8803,6 +9108,12 @@ module ts {
                     return checkImportDeclaration(<ImportDeclaration>node);
                 case SyntaxKind.ExportAssignment:
                     return checkExportAssignment(<ExportAssignment>node);
+                case SyntaxKind.EmptyStatement:
+                    checkGrammarForStatementInAmbientContext(node);
+                    return;
+                case SyntaxKind.DebuggerStatement:
+                    checkGrammarForStatementInAmbientContext(node);
+                    return;
             }
         }
 
@@ -8896,6 +9207,9 @@ module ts {
         function checkSourceFile(node: SourceFile) {
             var links = getNodeLinks(node);
             if (!(links.flags & NodeCheckFlags.TypeChecked)) {
+                // Grammar checking
+                checkGrammarSourceFile(node);
+
                 emitExtends = false;
                 potentialThisCollisions.length = 0;
 
@@ -9461,7 +9775,7 @@ module ts {
             return program.getDiagnostics(sourceFile).length !== 0 ||
                 hasEarlyErrors(sourceFile) ||
                 (compilerOptions.noEmitOnError && getDiagnostics(sourceFile).length !== 0);
-        }
+       }
 
         function hasEarlyErrors(sourceFile?: SourceFile): boolean {
             return forEach(getDiagnostics(sourceFile), d => d.isEarly);
@@ -9614,6 +9928,910 @@ module ts {
             anyArrayType = createArrayType(anyType);
         }
 
+
+        // GRAMMAR CHECKING
+        function checkGrammarModifiers(node: Node): boolean {
+            switch (node.kind) {
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.PropertySignature:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.IndexSignature:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.ExportAssignment:
+                case SyntaxKind.VariableStatement:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.TypeAliasDeclaration:
+                case SyntaxKind.ImportDeclaration:
+                case SyntaxKind.Parameter:
+                    break;
+                default:
+                    return false;
+            }
+
+            if (!node.modifiers) {
+                return;
+            }
+
+            var lastStatic: Node, lastPrivate: Node, lastProtected: Node, lastDeclare: Node;
+            var flags = 0;
+            for (var i = 0, n = node.modifiers.length; i < n; i++) {
+                var modifier = node.modifiers[i];
+
+                switch (modifier.kind) {
+                    case SyntaxKind.PublicKeyword:
+                    case SyntaxKind.ProtectedKeyword:
+                    case SyntaxKind.PrivateKeyword:
+                        var text: string;
+                        if (modifier.kind === SyntaxKind.PublicKeyword) {
+                            text = "public";
+                        }
+                        else if (modifier.kind === SyntaxKind.ProtectedKeyword) {
+                            text = "protected";
+                            lastProtected = modifier;
+                        }
+                        else {
+                            text = "private";
+                            lastPrivate = modifier;
+                        }
+
+                        if (flags & NodeFlags.AccessibilityModifier) {
+                            return grammarErrorOnNode(modifier, Diagnostics.Accessibility_modifier_already_seen);
+                        }
+                        else if (flags & NodeFlags.Static) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
+                        }
+                        else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, text);
+                        }
+                        flags |= modifierToFlag(modifier.kind);
+                        break;
+
+                    case SyntaxKind.StaticKeyword:
+                        if (flags & NodeFlags.Static) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static");
+                        }
+                        else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static");
+                        }
+                        else if (node.kind === SyntaxKind.Parameter) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
+                        }
+                        flags |= NodeFlags.Static;
+                        lastStatic = modifier;
+                        break;
+
+                    case SyntaxKind.ExportKeyword:
+                        if (flags & NodeFlags.Export) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export");
+                        }
+                        else if (flags & NodeFlags.Ambient) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
+                        }
+                        else if (node.parent.kind === SyntaxKind.ClassDeclaration) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export");
+                        }
+                        else if (node.kind === SyntaxKind.Parameter) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
+                        }
+                        flags |= NodeFlags.Export;
+                        break;
+
+                    case SyntaxKind.DeclareKeyword:
+                        if (flags & NodeFlags.Ambient) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");
+                        }
+                        else if (node.parent.kind === SyntaxKind.ClassDeclaration) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare");
+                        }
+                        else if (node.kind === SyntaxKind.Parameter) {
+                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
+                        }
+                        else if (isInAmbientContext(node.parent) && node.parent.kind === SyntaxKind.ModuleBlock) {
+                            return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
+                        }
+                        flags |= NodeFlags.Ambient;
+                        lastDeclare = modifier
+                        break;
+                }
+            }
+
+            if (node.kind === SyntaxKind.Constructor) {
+                if (flags & NodeFlags.Static) {
+                    return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
+                }
+                else if (flags & NodeFlags.Protected) {
+                    return grammarErrorOnNode(lastProtected, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected");
+                }
+                else if (flags & NodeFlags.Private) {
+                    return grammarErrorOnNode(lastPrivate, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private");
+                }
+            }
+            else if (node.kind === SyntaxKind.ImportDeclaration && flags & NodeFlags.Ambient) {
+                return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare");
+            }
+            else if (node.kind === SyntaxKind.InterfaceDeclaration && flags & NodeFlags.Ambient) {
+                return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare");
+            }
+        }
+
+        function checkGrammarForDisallowedTrailingComma(list: NodeArray<Node>): boolean {
+            if (list && list.hasTrailingComma) {
+                var start = list.end - ",".length;
+                var end = list.end;
+                var sourceFile = getSourceFileOfNode(list[0]);
+                return grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Trailing_comma_not_allowed);
+            }
+        }
+
+        function checkGrammarTypeParameterList(node: FunctionLikeDeclaration, typeParameters: NodeArray<TypeParameterDeclaration>): boolean {
+            if (checkGrammarForDisallowedTrailingComma(typeParameters)) {
+                return true;
+            }
+
+            if (typeParameters && typeParameters.length === 0) {
+                var start = typeParameters.pos - "<".length;
+                var sourceFile = getSourceFileOfNode(node);
+                var end = skipTrivia(sourceFile.text, typeParameters.end) + ">".length;
+                return grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Type_parameter_list_cannot_be_empty);
+            }
+        }
+
+        function checkGrammarParameterList(parameters: NodeArray<ParameterDeclaration>) {
+            if (checkGrammarForDisallowedTrailingComma(parameters)) {
+                return true;
+            }
+
+            var seenOptionalParameter = false;
+            var parameterCount = parameters.length;
+
+            for (var i = 0; i < parameterCount; i++) {
+                var parameter = parameters[i];
+                if (parameter.dotDotDotToken) {
+                    if (i !== (parameterCount - 1)) {
+                        return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
+                    }
+
+                    if (parameter.questionToken) {
+                        return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_rest_parameter_cannot_be_optional);
+                    }
+
+                    if (parameter.initializer) {
+                        return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_parameter_cannot_have_an_initializer);
+                    }
+                }
+                else if (parameter.questionToken || parameter.initializer) {
+                    seenOptionalParameter = true;
+
+                    if (parameter.questionToken && parameter.initializer) {
+                        return grammarErrorOnNode(parameter.name, Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
+                    }
+                }
+                else {
+                    if (seenOptionalParameter) {
+                        return grammarErrorOnNode(parameter.name, Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
+                    }
+                }
+            }
+        }
+
+        function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean {
+            // Prevent cascading error by short-circuit
+            return checkGrammarModifiers(node) || checkGrammarTypeParameterList(node, node.typeParameters) || checkGrammarParameterList(node.parameters);
+        }
+
+        function checkGrammarIndexSignatureParameters(node: SignatureDeclaration): boolean {
+            var parameter = node.parameters[0];
+            if (node.parameters.length !== 1) {
+                if (parameter) {
+                    return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+                }
+                else {
+                    return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
+                }
+            }
+            else if (parameter.dotDotDotToken) {
+                return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
+            }
+            else if (parameter.flags & NodeFlags.Modifier) {
+                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
+            }
+            else if (parameter.questionToken) {
+                return grammarErrorOnNode(parameter.questionToken, Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
+            }
+            else if (parameter.initializer) {
+                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
+            }
+            else if (!parameter.type) {
+                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
+            }
+            else if (parameter.type.kind !== SyntaxKind.StringKeyword && parameter.type.kind !== SyntaxKind.NumberKeyword) {
+                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_type_must_be_string_or_number);
+            }
+            else if (!node.type) {
+                return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_a_type_annotation);
+            }
+        }
+
+        function checkGrammarForIndexSignatureModifier(node: SignatureDeclaration): void {
+            if (node.flags & NodeFlags.Modifier) {
+                grammarErrorOnFirstToken(node, Diagnostics.Modifiers_not_permitted_on_index_signature_members);
+            }
+        }
+
+        function checkGrammarIndexSignature(node: SignatureDeclaration) {
+            // Prevent cascading error by short-circuit
+            checkGrammarModifiers(node) || checkGrammarIndexSignatureParameters(node) || checkGrammarForIndexSignatureModifier(node);
+        }
+
+        function checkGrammarForAtLeastOneTypeArgument(node: Node, typeArguments: NodeArray<TypeNode>): boolean {
+            if (typeArguments && typeArguments.length === 0) {
+                var sourceFile = getSourceFileOfNode(node);
+                var start = typeArguments.pos - "<".length;
+                var end = skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
+                return grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Type_argument_list_cannot_be_empty);
+            }
+        }
+
+        function checkGrammarTypeArguments(node: Node, typeArguments: NodeArray<TypeNode>): boolean {
+            return checkGrammarForDisallowedTrailingComma(typeArguments) ||
+                checkGrammarForAtLeastOneTypeArgument(node, typeArguments);
+        }
+
+        function checkGrammarForOmittedArgument(node: CallExpression, arguments: NodeArray<Expression>): boolean {
+            if (arguments) {
+                var sourceFile = getSourceFileOfNode(node);
+                for (var i = 0, n = arguments.length; i < n; i++) {
+                    var arg = arguments[i];
+                    if (arg.kind === SyntaxKind.OmittedExpression) {
+                        return grammarErrorAtPos(sourceFile, arg.pos, 0, Diagnostics.Argument_expression_expected);
+                    }
+                }
+            }
+        }
+
+        function checkGrammarArguments(node: CallExpression, arguments: NodeArray<Expression>): boolean {
+            return checkGrammarForDisallowedTrailingComma(arguments) ||
+                checkGrammarForOmittedArgument(node, arguments);
+        }
+
+        function checkGrammarHeritageClause(node: HeritageClause): boolean {
+            var types = node.types;
+            if (checkGrammarForDisallowedTrailingComma(types)) {
+                return true;
+            }
+            if (types && types.length === 0) {
+                var listType = tokenToString(node.token);
+                var sourceFile = getSourceFileOfNode(node);
+                return grammarErrorAtPos(sourceFile, types.pos, 0, Diagnostics._0_list_cannot_be_empty, listType)
+            }
+        }
+
+        function checkGrammarClassDeclarationHeritageClauses(node: ClassDeclaration) {
+            var seenExtendsClause = false;
+            var seenImplementsClause = false;
+
+            if (!checkGrammarModifiers(node) && node.heritageClauses) {
+                for (var i = 0, n = node.heritageClauses.length; i < n; i++) {
+                    Debug.assert(i <= 2);
+                    var heritageClause = node.heritageClauses[i];
+
+                    if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
+                        if (seenExtendsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen)
+                        }
+
+                        if (seenImplementsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_must_precede_implements_clause);
+                        }
+
+                        if (heritageClause.types.length > 1) {
+                            return grammarErrorOnFirstToken(heritageClause.types[1], Diagnostics.Classes_can_only_extend_a_single_class);
+                        }
+
+                        seenExtendsClause = true;
+                    }
+                    else {
+                        Debug.assert(heritageClause.token === SyntaxKind.ImplementsKeyword);
+                        if (seenImplementsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.implements_clause_already_seen);
+                        }
+
+                        seenImplementsClause = true;
+                    }
+
+                    // Grammar checking heritageClause inside class declaration
+                    checkGrammarHeritageClause(heritageClause);
+                }
+            }
+        }
+
+        function checkGrammarInterfaceDeclaration(node: InterfaceDeclaration) {
+            var seenExtendsClause = false;
+
+            if (node.heritageClauses) {
+                for (var i = 0, n = node.heritageClauses.length; i < n; i++) {
+                    Debug.assert(i <= 1);
+                    var heritageClause = node.heritageClauses[i];
+
+                    if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
+                        if (seenExtendsClause) {
+                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
+                        }
+
+                        seenExtendsClause = true;
+                    }
+                    else {
+                        Debug.assert(heritageClause.token === SyntaxKind.ImplementsKeyword);
+                        return grammarErrorOnFirstToken(heritageClause, Diagnostics.Interface_declaration_cannot_have_implements_clause);
+                    }
+
+                    // Grammar checking heritageClause inside class declaration
+                    checkGrammarHeritageClause(heritageClause);
+                }
+            }
+
+            return false;
+        }
+
+        function checkGrammarComputedPropertyName(node: Node): void {
+            // If node is not a computedPropertyName, just skip the grammar checking
+            if (node.kind !== SyntaxKind.ComputedPropertyName) {
+                return;
+            }
+            // Since computed properties are not supported in the type checker, disallow them in TypeScript 1.4
+            // Once full support is added, remove this error.
+            grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_not_currently_supported);
+            return;
+
+            var computedPropertyName = <ComputedPropertyName>node;
+            if (compilerOptions.target < ScriptTarget.ES6) {
+                grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher);
+            }
+            else if (computedPropertyName.expression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>computedPropertyName.expression).operator === SyntaxKind.CommaToken) {
+                grammarErrorOnNode(computedPropertyName.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
+            }
+        }
+
+        function checkGrammarForGenerator(node: FunctionLikeDeclaration) {
+            if (node.asteriskToken) {
+                return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_not_currently_supported);
+            }
+        }
+
+        function checkGrammarFunctionName(name: Node) {
+            // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1))
+            return checkGrammarEvalOrArgumentsInStrictMode(name, <Identifier>name);
+        }
+
+        function checkGrammarForInvalidQuestionMark(node: Declaration, questionToken: Node, message: DiagnosticMessage): boolean {
+            if (questionToken) {
+                return grammarErrorOnNode(questionToken, message);
+            }
+        }
+
+        function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression) {
+            var seen: Map<SymbolFlags> = {};
+            var Property = 1;
+            var GetAccessor = 2;
+            var SetAccesor = 4;
+            var GetOrSetAccessor = GetAccessor | SetAccesor;
+            var inStrictMode = (node.parserContextFlags & ParserContextFlags.StrictMode) !== 0;
+
+            for (var i = 0, n = node.properties.length; i < n; i++) {
+                var prop = node.properties[i];
+                var name = prop.name;
+                if (prop.kind === SyntaxKind.OmittedExpression || 
+                    name.kind === SyntaxKind.ComputedPropertyName) {
+                    // If the name is not a ComputedPropertyName, the grammar checking will skip it
+                    checkGrammarComputedPropertyName(<ComputedPropertyName>name);
+                    continue;
+                }
+
+                // ECMA-262 11.1.5 Object Initialiser
+                // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
+                // a.This production is contained in strict code and IsDataDescriptor(previous) is true and
+                // IsDataDescriptor(propId.descriptor) is true.
+                //    b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true.
+                //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
+                //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true
+                // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields
+                var currentKind: number;
+                if (prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                    // Grammar checking for computedPropertName and shorthandPropertyAssignment
+                    checkGrammarForInvalidQuestionMark(prop,(<PropertyAssignment>prop).questionToken, Diagnostics.An_object_member_cannot_be_declared_optional);
+                    if (name.kind === SyntaxKind.NumericLiteral) {
+                        checkGrammarNumbericLiteral(<Identifier>name);
+                    }
+                    currentKind = Property;
+                }
+                else if ( prop.kind === SyntaxKind.MethodDeclaration) {
+                    currentKind = Property;
+                }
+                else if (prop.kind === SyntaxKind.GetAccessor) {
+                    currentKind = GetAccessor;
+                }
+                else if (prop.kind === SyntaxKind.SetAccessor) {
+                    currentKind = SetAccesor;
+                }
+                else {
+                    Debug.fail("Unexpected syntax kind:" + prop.kind);
+                }
+
+                if (!hasProperty(seen, (<Identifier>name).text)) {
+                    seen[(<Identifier>name).text] = currentKind;
+                }
+                else {
+                    var existingKind = seen[(<Identifier>name).text];
+                    if (currentKind === Property && existingKind === Property) {
+                        if (inStrictMode) {
+                            grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode);
+                        }
+                    }
+                    else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) {
+                        if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) {
+                            seen[(<Identifier>name).text] = currentKind | existingKind;
+                        }
+                        else {
+                            return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
+                        }
+                    }
+                    else {
+                        return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
+                    }
+                }
+            }
+        }
+
+        function checkGrammarAccessor(accessor: MethodDeclaration): boolean {
+            var kind = accessor.kind;
+            if (compilerOptions.target < ScriptTarget.ES5) {
+                return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
+            }
+            else if (isInAmbientContext(accessor)) {
+                return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_be_declared_in_an_ambient_context);
+            }
+            else if (accessor.body === undefined) {
+                return grammarErrorAtPos(getSourceFileOfNode(accessor), accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
+            }
+            else if (accessor.typeParameters) {
+                return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_have_type_parameters);
+            }
+            else if (kind === SyntaxKind.GetAccessor && accessor.parameters.length) {
+                return grammarErrorOnNode(accessor.name, Diagnostics.A_get_accessor_cannot_have_parameters);
+            }
+            else if (kind === SyntaxKind.SetAccessor) {
+                if (accessor.type) {
+                    return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
+                }
+                else if (accessor.parameters.length !== 1) {
+                    return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
+                }
+                else {
+                    var parameter = accessor.parameters[0];
+                    if (parameter.dotDotDotToken) {
+                        return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_set_accessor_cannot_have_rest_parameter);
+                    }
+                    else if (parameter.flags & NodeFlags.Modifier) {
+                        return grammarErrorOnNode(accessor.name, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
+                    }
+                    else if (parameter.questionToken) {
+                        return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
+                    }
+                    else if (parameter.initializer) {
+                        return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
+                    }
+                }
+            }
+        }
+
+        function checkGrammarForDisallowedComputedProperty(node: DeclarationName, message: DiagnosticMessage) {
+            if (node.kind === SyntaxKind.ComputedPropertyName) {
+                return grammarErrorOnNode(node, message);
+            }
+        }
+
+        function checkGrammarMethod(node: MethodDeclaration) {
+            if (checkGrammarFunctionLikeDeclaration(node) ||
+                checkGrammarForGenerator(node)) {
+                return true;
+            }
+
+            if (node.parent.kind === SyntaxKind.ClassDeclaration) {
+                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) {
+                    return true;
+                }
+                // Technically, computed properties in ambient contexts is disallowed
+                // for property declarations and accessors too, not just methods.
+                // However, property declarations disallow computed names in general,
+                // and accessors are not allowed in ambient contexts in general,
+                // so this error only really matters for methods.
+                if (isInAmbientContext(node)) {
+                    return checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_an_ambient_context);
+                }
+                else if (!node.body) {
+                    return checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_method_overloads);
+                }
+            }
+            else if (node.parent.kind === SyntaxKind.InterfaceDeclaration) {
+                return checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_interfaces);
+            }
+            else if (node.parent.kind === SyntaxKind.TypeLiteral) {
+                return checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_type_literals);
+            }
+        }
+
+        function isIterationStatement(node: Node, lookInLabeledStatements: boolean): boolean {
+            switch (node.kind) {
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.DoStatement:
+                case SyntaxKind.WhileStatement:
+                    return true;
+                case SyntaxKind.LabeledStatement:
+                    return lookInLabeledStatements && isIterationStatement((<LabeledStatement>node).statement, lookInLabeledStatements);
+            }
+
+            return false;
+        }
+
+        function checkGrammarBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {
+            var current: Node = node;
+            while (current) {
+                if (isAnyFunction(current)) {
+                    return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);
+                }
+
+                switch (current.kind) {
+                    case SyntaxKind.LabeledStatement:
+                        if (node.label && (<LabeledStatement>current).label.text === node.label.text) {
+                            // found matching label - verify that label usage is correct
+                            // continue can only target labels that are on iteration statements
+                            var isMisplacedContinueLabel = node.kind === SyntaxKind.ContinueStatement
+                                && !isIterationStatement((<LabeledStatement>current).statement, /*lookInLabeledStatement*/ true);
+
+                            if (isMisplacedContinueLabel) {
+                                return grammarErrorOnNode(node, Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
+                            }
+
+                            return false;
+                        }
+                        break;
+                    case SyntaxKind.SwitchStatement:
+                        if (node.kind === SyntaxKind.BreakStatement && !node.label) {
+                            // unlabeled break within switch statement - ok
+                            return false;
+                        }
+                        break;
+                    default:
+                        if (isIterationStatement(current, /*lookInLabeledStatement*/ false) && !node.label) {
+                            // unlabeled break or continue within iteration statement - ok
+                            return false;
+                        }
+                        break;
+                }
+
+                current = current.parent;
+            }
+
+            if (node.label) {
+                var message = node.kind === SyntaxKind.BreakStatement
+                    ? Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement
+                    : Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
+
+                return grammarErrorOnNode(node, message)
+            }
+            else {
+                var message = node.kind === SyntaxKind.BreakStatement
+                    ? Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement
+                    : Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
+                return grammarErrorOnNode(node, message)
+            }
+        }
+
+        function checkGrammarVariableDeclaration(node: VariableDeclaration) {
+            if (isInAmbientContext(node)) {
+                if (isBindingPattern(node.name)) {
+                    return grammarErrorOnNode(node, Diagnostics.Destructuring_declarations_are_not_allowed_in_ambient_contexts);
+                }
+                if (node.initializer) {
+                    // Error on equals token which immediate precedes the initializer
+                    return grammarErrorAtPos(getSourceFileOfNode(node), node.initializer.pos - 1, 1, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+                }
+            }
+            else {
+                if (!node.initializer) {
+                    if (isBindingPattern(node.name) && !isBindingPattern(node.parent)) {
+                        return grammarErrorOnNode(node, Diagnostics.A_destructuring_declaration_must_have_an_initializer);
+                    }
+                    if (isConst(node)) {
+                        return grammarErrorOnNode(node, Diagnostics.const_declarations_must_be_initialized);
+                    }
+                }
+            }
+            // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code 
+            // and its Identifier is eval or arguments 
+            return  checkGrammarEvalOrArgumentsInStrictMode(node, <Identifier>node.name);
+        }
+
+        function checkGrammarVariableDeclarations(container: Node, declarations: NodeArray<VariableDeclaration>): boolean {
+            if (declarations) {
+                if (checkGrammarForDisallowedTrailingComma(declarations)) {
+                    return true;
+                }
+
+                if (!declarations.length) {
+                    return grammarErrorAtPos(getSourceFileOfNode(container), declarations.pos, declarations.end - declarations.pos, Diagnostics.Variable_declaration_list_cannot_be_empty);
+                }
+
+                var decl = declarations[0];
+                if (compilerOptions.target < ScriptTarget.ES6) {
+                    if (isLet(decl)) {
+                        return grammarErrorOnFirstToken(decl, Diagnostics.let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
+                    }
+                    else if (isConst(decl)) {
+                        return grammarErrorOnFirstToken(decl, Diagnostics.const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
+                    }
+                }
+            }
+        }
+
+        function allowLetAndConstDeclarations(parent: Node): boolean {
+            switch (parent.kind) {
+                case SyntaxKind.IfStatement:
+                case SyntaxKind.DoStatement:
+                case SyntaxKind.WhileStatement:
+                case SyntaxKind.WithStatement:
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                    return false;
+                case SyntaxKind.LabeledStatement:
+                    return allowLetAndConstDeclarations(parent.parent);
+            }
+
+            return true;
+        }
+
+        function checkGrammarForDisallowedLetOrConstStatement(node: VariableStatement) {
+            if (!allowLetAndConstDeclarations(node.parent)) {
+                if (isLet(node)) {
+                    return grammarErrorOnNode(node, Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
+                }
+                else if (isConst(node)) {
+                    return grammarErrorOnNode(node, Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
+                }
+            }
+        }
+
+        function isIntegerLiteral(expression: Expression): boolean {
+            if (expression.kind === SyntaxKind.PrefixUnaryExpression) {
+                var unaryExpression = <PrefixUnaryExpression>expression;
+                if (unaryExpression.operator === SyntaxKind.PlusToken || unaryExpression.operator === SyntaxKind.MinusToken) {
+                    expression = unaryExpression.operand;
+                }
+            }
+            if (expression.kind === SyntaxKind.NumericLiteral) {
+                // Allows for scientific notation since literalExpression.text was formed by
+                // coercing a number to a string. Sometimes this coercion can yield a string
+                // in scientific notation.
+                // We also don't need special logic for hex because a hex integer is converted
+                // to decimal when it is coerced.
+                return /^[0-9]+([eE]\+?[0-9]+)?$/.test((<LiteralExpression>expression).text);
+            }
+
+            return false;
+        }
+
+        function checkGrammarEnumDeclaration(enumDecl: EnumDeclaration): boolean {
+            var enumIsConst = (enumDecl.flags & NodeFlags.Const) !== 0;
+
+            var hasError = false;
+
+            // skip checks below for const enums  - they allow arbitrary initializers as long as they can be evaluated to constant expressions.
+            // since all values are known in compile time - it is not necessary to check that constant enum section precedes computed enum members.
+            if (!enumIsConst) {
+                var inConstantEnumMemberSection = true;
+                var inAmbientContext = isInAmbientContext(enumDecl);
+                for (var i = 0, n = enumDecl.members.length; i < n; i++) {
+                    var node = enumDecl.members[i];
+                    if (node.name.kind === SyntaxKind.ComputedPropertyName) {
+                        hasError = grammarErrorOnNode(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
+                    }
+                    else if (inAmbientContext) {
+                        if (node.initializer && !isIntegerLiteral(node.initializer)) {
+                            hasError = grammarErrorOnNode(node.name, Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers) || hasError;
+                        }
+                    }
+                    else if (node.initializer) {
+                        inConstantEnumMemberSection = isIntegerLiteral(node.initializer);
+                    }
+                    else if (!inConstantEnumMemberSection) {
+                        hasError = grammarErrorOnNode(node.name, Diagnostics.Enum_member_must_have_initializer) || hasError;
+                    }
+                }
+            }
+
+            return hasError;
+        }
+
+        function hasParseDiagnostics(sourceFile: SourceFile): boolean {
+            return sourceFile.parseDiagnostics.length > 0;
+        }
+
+        function scanToken(scanner: Scanner, pos: number) {
+            scanner.setTextPos(pos);
+            scanner.scan();
+            var start = scanner.getTokenPos();
+            return start;
+        }
+
+        function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
+            var sourceFile = getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                var scanner = createScanner(compilerOptions.target, /*skipTrivia*/ true, sourceFile.text);
+                var start = scanToken(scanner, node.pos);
+                diagnostics.push(createFileDiagnostic(sourceFile, start, scanner.getTextPos() - start, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+
+        function grammarErrorAtPos(sourceFile: SourceFile, start: number, length: number, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
+            if (!hasParseDiagnostics(sourceFile)) {
+                diagnostics.push(createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+
+        function grammarErrorOnNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
+            var sourceFile = getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                var span = getErrorSpanForNode(node);
+                var start = span.end > span.pos ? skipTrivia(sourceFile.text, span.pos) : span.pos;
+                diagnostics.push(createFileDiagnostic(sourceFile, start, span.end - start, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+
+        function checkGrammarEvalOrArgumentsInStrictMode(contextNode: Node, identifier: Identifier): boolean {
+            if (contextNode && (contextNode.parserContextFlags & ParserContextFlags.StrictMode) && isEvalOrArgumentsIdentifier(identifier)) {
+                var name = declarationNameToString(identifier);
+                return grammarErrorOnNode(identifier, Diagnostics.Invalid_use_of_0_in_strict_mode, name);
+            }
+        }
+
+        function checkGrammarConstructorTypeParameters(node: ConstructorDeclaration) {
+            if (node.typeParameters) {
+                return grammarErrorAtPos(getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
+            }
+        }
+
+        function checkGrammarConstructorTypeAnnotation(node: ConstructorDeclaration) {
+            if (node.type) {
+                return grammarErrorOnNode(node.type, Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
+            }
+        }
+
+        function checkGrammarProperty(node: PropertyDeclaration) {
+            if (node.parent.kind === SyntaxKind.ClassDeclaration) {
+                if (checkGrammarForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional) ||
+                    checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_class_property_declarations)) {
+                    return true;
+                }
+            }
+            else if (node.parent.kind === SyntaxKind.InterfaceDeclaration) {
+                if (checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_interfaces)) {
+                    return true;
+                }
+            }
+            else if (node.parent.kind === SyntaxKind.TypeLiteral) {
+                if (checkGrammarForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_type_literals)) {
+                    return true;
+                }
+            }
+
+            if (isInAmbientContext(node) && node.initializer) {
+                return grammarErrorOnFirstToken(node.initializer, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
+            }
+        }
+
+        function checkGrammarTopLevelElementForRequiredDeclareModifier(node: Node): boolean {
+            // A declare modifier is required for any top level .d.ts declaration except export=, interfaces and imports:
+            // categories:
+            //
+            //  DeclarationElement:
+            //     ExportAssignment
+            //     export_opt   InterfaceDeclaration
+            //     export_opt   ImportDeclaration
+            //     export_opt   ExternalImportDeclaration
+            //     export_opt   AmbientDeclaration
+            //
+            if (node.kind === SyntaxKind.InterfaceDeclaration ||
+                node.kind === SyntaxKind.ImportDeclaration ||
+                node.kind === SyntaxKind.ExportAssignment ||
+                (node.flags & NodeFlags.Ambient)) {
+
+                return false;
+            }
+
+            return grammarErrorOnFirstToken(node, Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
+        }
+
+        function checkGrammarTopLevelElementsForRequiredDeclareModifier(file: SourceFile): boolean {
+            for (var i = 0, n = file.statements.length; i < n; i++) {
+                var decl = file.statements[i];
+                if (isDeclaration(decl) || decl.kind === SyntaxKind.VariableStatement) {
+                    if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        function checkGrammarSourceFile(node: SourceFile): boolean {
+            return isInAmbientContext(node) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
+        }
+
+        function checkGrammarForStatementInAmbientContext(node: Node): boolean {
+            if (isInAmbientContext(node)) {
+                // An accessors is already reported about the ambient context
+                if (isAccessor(node.parent.kind)) {
+                    return getNodeLinks(node).hasReportedStatementInAmbientContext = true;
+                }
+
+                // Find containing block which is either Block, ModuleBlock, SourceFile
+                var links = getNodeLinks(node);
+                if (!links.hasReportedStatementInAmbientContext && isAnyFunction(node.parent)) {
+                    return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts)
+                }
+                
+                // We are either parented by another statement, or some sort of block.
+                // If we're in a block, we only want to really report an error once
+                // to prevent noisyness.  So use a bit on the block to indicate if
+                // this has already been reported, and don't report if it has.
+                //
+                if (node.parent.kind === SyntaxKind.Block || node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) {
+                    var links = getNodeLinks(node.parent);
+                    // Check if the containing block ever report this error
+                    if (!links.hasReportedStatementInAmbientContext) {
+                        return links.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
+                    }
+                }
+                else {
+                    // We must be parented by a statement.  If so, there's no need
+                    // to report the error as our parent will have already done it.
+                    // Debug.assert(isStatement(node.parent));
+                }
+            }
+        }
+
+        function checkGrammarNumbericLiteral(node: Identifier): boolean {
+            // Grammar checking
+            if (node.flags & NodeFlags.OctalLiteral) {
+                if (node.parserContextFlags & ParserContextFlags.StrictMode) {
+                    return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode);
+                }
+                else if (compilerOptions.target >= ScriptTarget.ES5) {
+                    return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
+                }
+            }
+        }
+
+        function grammarErrorAfterFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
+            var sourceFile = getSourceFileOfNode(node);
+            if (!hasParseDiagnostics(sourceFile)) {
+                var scanner = createScanner(compilerOptions.target, /*skipTrivia*/ true, sourceFile.text);
+                scanToken(scanner, node.pos);
+                diagnostics.push(createFileDiagnostic(sourceFile, scanner.getTextPos(), 0, message, arg0, arg1, arg2));
+                return true;
+            }
+        }
+
         initializeTypeChecker();
 
         return checker;
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index 9c4ccfb5215..8e0d6ce8e98 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -4,89 +4,87 @@ module ts {
     export var Diagnostics = {
         Unterminated_string_literal: { code: 1002, category: DiagnosticCategory.Error, key: "Unterminated string literal." },
         Identifier_expected: { code: 1003, category: DiagnosticCategory.Error, key: "Identifier expected." },
-        _0_expected: { code: 1005, category: DiagnosticCategory.Error, key: "'{0}' expected." },
+        _0_expected: { code: 1005, category: DiagnosticCategory.Error, key: "'{0}' expected.", isEarly: true },
         A_file_cannot_have_a_reference_to_itself: { code: 1006, category: DiagnosticCategory.Error, key: "A file cannot have a reference to itself." },
-        Trailing_comma_not_allowed: { code: 1009, category: DiagnosticCategory.Error, key: "Trailing comma not allowed." },
+        Trailing_comma_not_allowed: { code: 1009, category: DiagnosticCategory.Error, key: "Trailing comma not allowed.", isEarly: true },
         Asterisk_Slash_expected: { code: 1010, category: DiagnosticCategory.Error, key: "'*/' expected." },
         Unexpected_token: { code: 1012, category: DiagnosticCategory.Error, key: "Unexpected token." },
-        Catch_clause_parameter_cannot_have_a_type_annotation: { code: 1013, category: DiagnosticCategory.Error, key: "Catch clause parameter cannot have a type annotation." },
-        A_rest_parameter_must_be_last_in_a_parameter_list: { code: 1014, category: DiagnosticCategory.Error, key: "A rest parameter must be last in a parameter list." },
-        Parameter_cannot_have_question_mark_and_initializer: { code: 1015, category: DiagnosticCategory.Error, key: "Parameter cannot have question mark and initializer." },
-        A_required_parameter_cannot_follow_an_optional_parameter: { code: 1016, category: DiagnosticCategory.Error, key: "A required parameter cannot follow an optional parameter." },
-        An_index_signature_cannot_have_a_rest_parameter: { code: 1017, category: DiagnosticCategory.Error, key: "An index signature cannot have a rest parameter." },
-        An_index_signature_parameter_cannot_have_an_accessibility_modifier: { code: 1018, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an accessibility modifier." },
-        An_index_signature_parameter_cannot_have_a_question_mark: { code: 1019, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have a question mark." },
-        An_index_signature_parameter_cannot_have_an_initializer: { code: 1020, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an initializer." },
-        An_index_signature_must_have_a_type_annotation: { code: 1021, category: DiagnosticCategory.Error, key: "An index signature must have a type annotation." },
-        An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: DiagnosticCategory.Error, key: "An index signature parameter must have a type annotation." },
-        An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: DiagnosticCategory.Error, key: "An index signature parameter type must be 'string' or 'number'." },
+        Catch_clause_parameter_cannot_have_a_type_annotation: { code: 1013, category: DiagnosticCategory.Error, key: "Catch clause parameter cannot have a type annotation.", isEarly: true },
+        A_rest_parameter_must_be_last_in_a_parameter_list: { code: 1014, category: DiagnosticCategory.Error, key: "A rest parameter must be last in a parameter list.", isEarly: true },
+        Parameter_cannot_have_question_mark_and_initializer: { code: 1015, category: DiagnosticCategory.Error, key: "Parameter cannot have question mark and initializer.", isEarly: true },
+        A_required_parameter_cannot_follow_an_optional_parameter: { code: 1016, category: DiagnosticCategory.Error, key: "A required parameter cannot follow an optional parameter.", isEarly: true },
+        An_index_signature_cannot_have_a_rest_parameter: { code: 1017, category: DiagnosticCategory.Error, key: "An index signature cannot have a rest parameter.", isEarly: true },
+        An_index_signature_parameter_cannot_have_an_accessibility_modifier: { code: 1018, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an accessibility modifier.", isEarly: true },
+        An_index_signature_parameter_cannot_have_a_question_mark: { code: 1019, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have a question mark.", isEarly: true },
+        An_index_signature_parameter_cannot_have_an_initializer: { code: 1020, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an initializer.", isEarly: true },
+        An_index_signature_must_have_a_type_annotation: { code: 1021, category: DiagnosticCategory.Error, key: "An index signature must have a type annotation.", isEarly: true },
+        An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: DiagnosticCategory.Error, key: "An index signature parameter must have a type annotation.", isEarly: true },
+        An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: DiagnosticCategory.Error, key: "An index signature parameter type must be 'string' or 'number'.", isEarly: true },
         A_class_or_interface_declaration_can_only_have_one_extends_clause: { code: 1024, category: DiagnosticCategory.Error, key: "A class or interface declaration can only have one 'extends' clause." },
         An_extends_clause_must_precede_an_implements_clause: { code: 1025, category: DiagnosticCategory.Error, key: "An 'extends' clause must precede an 'implements' clause." },
         A_class_can_only_extend_a_single_class: { code: 1026, category: DiagnosticCategory.Error, key: "A class can only extend a single class." },
         A_class_declaration_can_only_have_one_implements_clause: { code: 1027, category: DiagnosticCategory.Error, key: "A class declaration can only have one 'implements' clause." },
-        Accessibility_modifier_already_seen: { code: 1028, category: DiagnosticCategory.Error, key: "Accessibility modifier already seen." },
-        _0_modifier_must_precede_1_modifier: { code: 1029, category: DiagnosticCategory.Error, key: "'{0}' modifier must precede '{1}' modifier." },
-        _0_modifier_already_seen: { code: 1030, category: DiagnosticCategory.Error, key: "'{0}' modifier already seen." },
-        _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a class element." },
+        Accessibility_modifier_already_seen: { code: 1028, category: DiagnosticCategory.Error, key: "Accessibility modifier already seen.", isEarly: true },
+        _0_modifier_must_precede_1_modifier: { code: 1029, category: DiagnosticCategory.Error, key: "'{0}' modifier must precede '{1}' modifier.", isEarly: true },
+        _0_modifier_already_seen: { code: 1030, category: DiagnosticCategory.Error, key: "'{0}' modifier already seen.", isEarly: true },
+        _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a class element.", isEarly: true },
         An_interface_declaration_cannot_have_an_implements_clause: { code: 1032, category: DiagnosticCategory.Error, key: "An interface declaration cannot have an 'implements' clause." },
         super_must_be_followed_by_an_argument_list_or_member_access: { code: 1034, category: DiagnosticCategory.Error, key: "'super' must be followed by an argument list or member access." },
-        Only_ambient_modules_can_use_quoted_names: { code: 1035, category: DiagnosticCategory.Error, key: "Only ambient modules can use quoted names." },
-        Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: DiagnosticCategory.Error, key: "Statements are not allowed in ambient contexts." },
-        A_function_implementation_cannot_be_declared_in_an_ambient_context: { code: 1037, category: DiagnosticCategory.Error, key: "A function implementation cannot be declared in an ambient context." },
-        A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used in an already ambient context." },
-        Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: DiagnosticCategory.Error, key: "Initializers are not allowed in ambient contexts." },
-        _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a module element." },
-        A_declare_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an interface declaration." },
+        Only_ambient_modules_can_use_quoted_names: { code: 1035, category: DiagnosticCategory.Error, key: "Only ambient modules can use quoted names.", isEarly: true },
+        Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: DiagnosticCategory.Error, key: "Statements are not allowed in ambient contexts.", isEarly: true },
+        A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used in an already ambient context.", isEarly: true },
+        Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: DiagnosticCategory.Error, key: "Initializers are not allowed in ambient contexts.", isEarly: true },
+        _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a module element.", isEarly: true },
+        A_declare_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an interface declaration.", isEarly: true },
         A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: { code: 1046, category: DiagnosticCategory.Error, key: "A 'declare' modifier is required for a top level declaration in a .d.ts file." },
-        A_rest_parameter_cannot_be_optional: { code: 1047, category: DiagnosticCategory.Error, key: "A rest parameter cannot be optional." },
-        A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: DiagnosticCategory.Error, key: "A rest parameter cannot have an initializer." },
-        A_set_accessor_must_have_exactly_one_parameter: { code: 1049, category: DiagnosticCategory.Error, key: "A 'set' accessor must have exactly one parameter." },
-        A_set_accessor_cannot_have_an_optional_parameter: { code: 1051, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have an optional parameter." },
-        A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: DiagnosticCategory.Error, key: "A 'set' accessor parameter cannot have an initializer." },
-        A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have rest parameter." },
-        A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters." },
-        Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." },
-        Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." },
-        An_export_assignment_cannot_be_used_in_an_internal_module: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in an internal module." },
-        Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." },
+        A_rest_parameter_cannot_be_optional: { code: 1047, category: DiagnosticCategory.Error, key: "A rest parameter cannot be optional.", isEarly: true },
+        A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: DiagnosticCategory.Error, key: "A rest parameter cannot have an initializer.", isEarly: true },
+        A_set_accessor_must_have_exactly_one_parameter: { code: 1049, category: DiagnosticCategory.Error, key: "A 'set' accessor must have exactly one parameter.", isEarly: true },
+        A_set_accessor_cannot_have_an_optional_parameter: { code: 1051, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have an optional parameter.", isEarly: true },
+        A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: DiagnosticCategory.Error, key: "A 'set' accessor parameter cannot have an initializer.", isEarly: true },
+        A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have rest parameter.", isEarly: true },
+        A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters.", isEarly: true },
+        Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher.", isEarly: true },
+        Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer.", isEarly: true },
+        An_export_assignment_cannot_be_used_in_an_internal_module: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in an internal module.", isEarly: true },
+        Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers.", isEarly: true },
         Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." },
-        A_declare_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an import declaration." },
+        A_declare_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an import declaration.", isEarly: true },
         Invalid_reference_directive_syntax: { code: 1084, category: DiagnosticCategory.Error, key: "Invalid 'reference' directive syntax." },
-        Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: DiagnosticCategory.Error, key: "Octal literals are not available when targeting ECMAScript 5 and higher." },
-        An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: DiagnosticCategory.Error, key: "An accessor cannot be declared in an ambient context." },
-        _0_modifier_cannot_appear_on_a_constructor_declaration: { code: 1089, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a constructor declaration." },
-        _0_modifier_cannot_appear_on_a_parameter: { code: 1090, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a parameter." },
-        Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: { code: 1091, category: DiagnosticCategory.Error, key: "Only a single variable declaration is allowed in a 'for...in' statement." },
-        Type_parameters_cannot_appear_on_a_constructor_declaration: { code: 1092, category: DiagnosticCategory.Error, key: "Type parameters cannot appear on a constructor declaration." },
-        Type_annotation_cannot_appear_on_a_constructor_declaration: { code: 1093, category: DiagnosticCategory.Error, key: "Type annotation cannot appear on a constructor declaration." },
-        An_accessor_cannot_have_type_parameters: { code: 1094, category: DiagnosticCategory.Error, key: "An accessor cannot have type parameters." },
-        A_set_accessor_cannot_have_a_return_type_annotation: { code: 1095, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have a return type annotation." },
-        An_index_signature_must_have_exactly_one_parameter: { code: 1096, category: DiagnosticCategory.Error, key: "An index signature must have exactly one parameter." },
-        _0_list_cannot_be_empty: { code: 1097, category: DiagnosticCategory.Error, key: "'{0}' list cannot be empty." },
-        Type_parameter_list_cannot_be_empty: { code: 1098, category: DiagnosticCategory.Error, key: "Type parameter list cannot be empty." },
-        Type_argument_list_cannot_be_empty: { code: 1099, category: DiagnosticCategory.Error, key: "Type argument list cannot be empty." },
-        Invalid_use_of_0_in_strict_mode: { code: 1100, category: DiagnosticCategory.Error, key: "Invalid use of '{0}' in strict mode." },
-        with_statements_are_not_allowed_in_strict_mode: { code: 1101, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in strict mode." },
-        delete_cannot_be_called_on_an_identifier_in_strict_mode: { code: 1102, category: DiagnosticCategory.Error, key: "'delete' cannot be called on an identifier in strict mode." },
-        A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: { code: 1104, category: DiagnosticCategory.Error, key: "A 'continue' statement can only be used within an enclosing iteration statement." },
-        A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: { code: 1105, category: DiagnosticCategory.Error, key: "A 'break' statement can only be used within an enclosing iteration or switch statement." },
-        Jump_target_cannot_cross_function_boundary: { code: 1107, category: DiagnosticCategory.Error, key: "Jump target cannot cross function boundary." },
-        A_return_statement_can_only_be_used_within_a_function_body: { code: 1108, category: DiagnosticCategory.Error, key: "A 'return' statement can only be used within a function body." },
-        Expression_expected: { code: 1109, category: DiagnosticCategory.Error, key: "Expression expected." },
-        Type_expected: { code: 1110, category: DiagnosticCategory.Error, key: "Type expected." },
-        A_constructor_implementation_cannot_be_declared_in_an_ambient_context: { code: 1111, category: DiagnosticCategory.Error, key: "A constructor implementation cannot be declared in an ambient context." },
-        A_class_member_cannot_be_declared_optional: { code: 1112, category: DiagnosticCategory.Error, key: "A class member cannot be declared optional." },
-        A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: { code: 1113, category: DiagnosticCategory.Error, key: "A 'default' clause cannot appear more than once in a 'switch' statement." },
-        Duplicate_label_0: { code: 1114, category: DiagnosticCategory.Error, key: "Duplicate label '{0}'" },
-        A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: { code: 1115, category: DiagnosticCategory.Error, key: "A 'continue' statement can only jump to a label of an enclosing iteration statement." },
-        A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: { code: 1116, category: DiagnosticCategory.Error, key: "A 'break' statement can only jump to a label of an enclosing statement." },
-        An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: { code: 1117, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple properties with the same name in strict mode." },
-        An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple get/set accessors with the same name." },
-        An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: DiagnosticCategory.Error, key: "An object literal cannot have property and accessor with the same name." },
-        An_export_assignment_cannot_have_modifiers: { code: 1120, category: DiagnosticCategory.Error, key: "An export assignment cannot have modifiers." },
-        Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: DiagnosticCategory.Error, key: "Octal literals are not allowed in strict mode." },
-        A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: DiagnosticCategory.Error, key: "A tuple type element list cannot be empty." },
-        Variable_declaration_list_cannot_be_empty: { code: 1123, category: DiagnosticCategory.Error, key: "Variable declaration list cannot be empty." },
+        Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: DiagnosticCategory.Error, key: "Octal literals are not available when targeting ECMAScript 5 and higher.", isEarly: true },
+        An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: DiagnosticCategory.Error, key: "An accessor cannot be declared in an ambient context.", isEarly: true },
+        _0_modifier_cannot_appear_on_a_constructor_declaration: { code: 1089, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a constructor declaration.", isEarly: true },
+        _0_modifier_cannot_appear_on_a_parameter: { code: 1090, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a parameter.", isEarly: true },
+        Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: { code: 1091, category: DiagnosticCategory.Error, key: "Only a single variable declaration is allowed in a 'for...in' statement.", isEarly: true },
+        Type_parameters_cannot_appear_on_a_constructor_declaration: { code: 1092, category: DiagnosticCategory.Error, key: "Type parameters cannot appear on a constructor declaration.", isEarly: true },
+        Type_annotation_cannot_appear_on_a_constructor_declaration: { code: 1093, category: DiagnosticCategory.Error, key: "Type annotation cannot appear on a constructor declaration.", isEarly: true },
+        An_accessor_cannot_have_type_parameters: { code: 1094, category: DiagnosticCategory.Error, key: "An accessor cannot have type parameters.", isEarly: true },
+        A_set_accessor_cannot_have_a_return_type_annotation: { code: 1095, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have a return type annotation.", isEarly: true },
+        An_index_signature_must_have_exactly_one_parameter: { code: 1096, category: DiagnosticCategory.Error, key: "An index signature must have exactly one parameter.", isEarly: true },
+        _0_list_cannot_be_empty: { code: 1097, category: DiagnosticCategory.Error, key: "'{0}' list cannot be empty.", isEarly: true },
+        Type_parameter_list_cannot_be_empty: { code: 1098, category: DiagnosticCategory.Error, key: "Type parameter list cannot be empty.", isEarly: true },
+        Type_argument_list_cannot_be_empty: { code: 1099, category: DiagnosticCategory.Error, key: "Type argument list cannot be empty.", isEarly: true },
+        Invalid_use_of_0_in_strict_mode: { code: 1100, category: DiagnosticCategory.Error, key: "Invalid use of '{0}' in strict mode.", isEarly: true },
+        with_statements_are_not_allowed_in_strict_mode: { code: 1101, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in strict mode.", isEarly: true },
+        delete_cannot_be_called_on_an_identifier_in_strict_mode: { code: 1102, category: DiagnosticCategory.Error, key: "'delete' cannot be called on an identifier in strict mode.", isEarly: true },
+        A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: { code: 1104, category: DiagnosticCategory.Error, key: "A 'continue' statement can only be used within an enclosing iteration statement.", isEarly: true },
+        A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: { code: 1105, category: DiagnosticCategory.Error, key: "A 'break' statement can only be used within an enclosing iteration or switch statement.", isEarly: true },
+        Jump_target_cannot_cross_function_boundary: { code: 1107, category: DiagnosticCategory.Error, key: "Jump target cannot cross function boundary.", isEarly: true },
+        A_return_statement_can_only_be_used_within_a_function_body: { code: 1108, category: DiagnosticCategory.Error, key: "A 'return' statement can only be used within a function body.", isEarly: true },
+        Expression_expected: { code: 1109, category: DiagnosticCategory.Error, key: "Expression expected.", isEarly: true },
+        Type_expected: { code: 1110, category: DiagnosticCategory.Error, key: "Type expected.", isEarly: true },
+        A_class_member_cannot_be_declared_optional: { code: 1112, category: DiagnosticCategory.Error, key: "A class member cannot be declared optional.", isEarly: true },
+        A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: { code: 1113, category: DiagnosticCategory.Error, key: "A 'default' clause cannot appear more than once in a 'switch' statement.", isEarly: true },
+        Duplicate_label_0: { code: 1114, category: DiagnosticCategory.Error, key: "Duplicate label '{0}'", isEarly: true },
+        A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: { code: 1115, category: DiagnosticCategory.Error, key: "A 'continue' statement can only jump to a label of an enclosing iteration statement.", isEarly: true },
+        A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: { code: 1116, category: DiagnosticCategory.Error, key: "A 'break' statement can only jump to a label of an enclosing statement.", isEarly: true },
+        An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: { code: 1117, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple properties with the same name in strict mode.", isEarly: true },
+        An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple get/set accessors with the same name.", isEarly: true },
+        An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: DiagnosticCategory.Error, key: "An object literal cannot have property and accessor with the same name.", isEarly: true },
+        An_export_assignment_cannot_have_modifiers: { code: 1120, category: DiagnosticCategory.Error, key: "An export assignment cannot have modifiers.", isEarly: true },
+        Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: DiagnosticCategory.Error, key: "Octal literals are not allowed in strict mode.", isEarly: true },
+        A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: DiagnosticCategory.Error, key: "A tuple type element list cannot be empty.", isEarly: true },
+        Variable_declaration_list_cannot_be_empty: { code: 1123, category: DiagnosticCategory.Error, key: "Variable declaration list cannot be empty.", isEarly: true },
         Digit_expected: { code: 1124, category: DiagnosticCategory.Error, key: "Digit expected." },
         Hexadecimal_digit_expected: { code: 1125, category: DiagnosticCategory.Error, key: "Hexadecimal digit expected." },
         Unexpected_end_of_text: { code: 1126, category: DiagnosticCategory.Error, key: "Unexpected end of text." },
@@ -98,52 +96,53 @@ module ts {
         Enum_member_expected: { code: 1132, category: DiagnosticCategory.Error, key: "Enum member expected." },
         Type_reference_expected: { code: 1133, category: DiagnosticCategory.Error, key: "Type reference expected." },
         Variable_declaration_expected: { code: 1134, category: DiagnosticCategory.Error, key: "Variable declaration expected." },
-        Argument_expression_expected: { code: 1135, category: DiagnosticCategory.Error, key: "Argument expression expected." },
+        Argument_expression_expected: { code: 1135, category: DiagnosticCategory.Error, key: "Argument expression expected.", isEarly: true },
         Property_assignment_expected: { code: 1136, category: DiagnosticCategory.Error, key: "Property assignment expected." },
         Expression_or_comma_expected: { code: 1137, category: DiagnosticCategory.Error, key: "Expression or comma expected." },
         Parameter_declaration_expected: { code: 1138, category: DiagnosticCategory.Error, key: "Parameter declaration expected." },
         Type_parameter_declaration_expected: { code: 1139, category: DiagnosticCategory.Error, key: "Type parameter declaration expected." },
         Type_argument_expected: { code: 1140, category: DiagnosticCategory.Error, key: "Type argument expected." },
-        String_literal_expected: { code: 1141, category: DiagnosticCategory.Error, key: "String literal expected." },
-        Line_break_not_permitted_here: { code: 1142, category: DiagnosticCategory.Error, key: "Line break not permitted here." },
+        String_literal_expected: { code: 1141, category: DiagnosticCategory.Error, key: "String literal expected.", isEarly: true },
+        Line_break_not_permitted_here: { code: 1142, category: DiagnosticCategory.Error, key: "Line break not permitted here.", isEarly: true },
         or_expected: { code: 1144, category: DiagnosticCategory.Error, key: "'{' or ';' expected." },
-        Modifiers_not_permitted_on_index_signature_members: { code: 1145, category: DiagnosticCategory.Error, key: "Modifiers not permitted on index signature members." },
+        Modifiers_not_permitted_on_index_signature_members: { code: 1145, category: DiagnosticCategory.Error, key: "Modifiers not permitted on index signature members.", isEarly: true },
         Declaration_expected: { code: 1146, category: DiagnosticCategory.Error, key: "Declaration expected." },
-        Import_declarations_in_an_internal_module_cannot_reference_an_external_module: { code: 1147, category: DiagnosticCategory.Error, key: "Import declarations in an internal module cannot reference an external module." },
+        Import_declarations_in_an_internal_module_cannot_reference_an_external_module: { code: 1147, category: DiagnosticCategory.Error, key: "Import declarations in an internal module cannot reference an external module.", isEarly: true },
         Cannot_compile_external_modules_unless_the_module_flag_is_provided: { code: 1148, category: DiagnosticCategory.Error, key: "Cannot compile external modules unless the '--module' flag is provided." },
         Filename_0_differs_from_already_included_filename_1_only_in_casing: { code: 1149, category: DiagnosticCategory.Error, key: "Filename '{0}' differs from already included filename '{1}' only in casing" },
-        new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead." },
+        new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.", isEarly: true },
         var_let_or_const_expected: { code: 1152, category: DiagnosticCategory.Error, key: "'var', 'let' or 'const' expected." },
-        let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1153, category: DiagnosticCategory.Error, key: "'let' declarations are only available when targeting ECMAScript 6 and higher." },
-        const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1154, category: DiagnosticCategory.Error, key: "'const' declarations are only available when targeting ECMAScript 6 and higher." },
-        const_declarations_must_be_initialized: { code: 1155, category: DiagnosticCategory.Error, key: "'const' declarations must be initialized" },
-        const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block." },
-        let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." },
-        Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1159, category: DiagnosticCategory.Error, key: "Tagged templates are only available when targeting ECMAScript 6 and higher." },
+        let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1153, category: DiagnosticCategory.Error, key: "'let' declarations are only available when targeting ECMAScript 6 and higher.", isEarly: true },
+        const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1154, category: DiagnosticCategory.Error, key: "'const' declarations are only available when targeting ECMAScript 6 and higher.", isEarly: true },
+        const_declarations_must_be_initialized: { code: 1155, category: DiagnosticCategory.Error, key: "'const' declarations must be initialized", isEarly: true },
+        const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block.", isEarly: true },
+        let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block.", isEarly: true },
+        Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1159, category: DiagnosticCategory.Error, key: "Tagged templates are only available when targeting ECMAScript 6 and higher.", isEarly: true },
         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." },
-        Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums." },
-        Computed_property_names_are_not_allowed_in_an_ambient_context: { code: 1165, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in an ambient context." },
-        Computed_property_names_are_not_allowed_in_class_property_declarations: { code: 1166, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in class property declarations." },
-        Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1167, category: DiagnosticCategory.Error, key: "Computed property names are only available when targeting ECMAScript 6 and higher." },
-        Computed_property_names_are_not_allowed_in_method_overloads: { code: 1168, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in method overloads." },
-        Computed_property_names_are_not_allowed_in_interfaces: { code: 1169, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in interfaces." },
-        Computed_property_names_are_not_allowed_in_type_literals: { code: 1170, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in type literals." },
+        An_object_member_cannot_be_declared_optional: { code: 1162, category: DiagnosticCategory.Error, key: "An object member cannot be declared optional.", isEarly: true },
+        yield_expression_must_be_contained_within_a_generator_declaration: { code: 1163, category: DiagnosticCategory.Error, key: "'yield' expression must be contained_within a generator declaration.", isEarly: true },
+        Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums.", isEarly: true },
+        Computed_property_names_are_not_allowed_in_an_ambient_context: { code: 1165, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in an ambient context.", isEarly: true },
+        Computed_property_names_are_not_allowed_in_class_property_declarations: { code: 1166, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in class property declarations.", isEarly: true },
+        Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1167, category: DiagnosticCategory.Error, key: "Computed property names are only available when targeting ECMAScript 6 and higher.", isEarly: true },
+        Computed_property_names_are_not_allowed_in_method_overloads: { code: 1168, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in method overloads.", isEarly: true },
+        Computed_property_names_are_not_allowed_in_interfaces: { code: 1169, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in interfaces.", isEarly: true },
+        Computed_property_names_are_not_allowed_in_type_literals: { code: 1170, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in type literals.", isEarly: true },
         A_comma_expression_is_not_allowed_in_a_computed_property_name: { code: 1171, category: DiagnosticCategory.Error, key: "A comma expression is not allowed in a computed property name." },
-        extends_clause_already_seen: { code: 1172, category: DiagnosticCategory.Error, key: "'extends' clause already seen." },
-        extends_clause_must_precede_implements_clause: { code: 1173, category: DiagnosticCategory.Error, key: "'extends' clause must precede 'implements' clause." },
-        Classes_can_only_extend_a_single_class: { code: 1174, category: DiagnosticCategory.Error, key: "Classes can only extend a single class." },
-        implements_clause_already_seen: { code: 1175, category: DiagnosticCategory.Error, key: "'implements' clause already seen." },
-        Interface_declaration_cannot_have_implements_clause: { code: 1176, category: DiagnosticCategory.Error, key: "Interface declaration cannot have 'implements' clause." },
+        extends_clause_already_seen: { code: 1172, category: DiagnosticCategory.Error, key: "'extends' clause already seen.", isEarly: true },
+        extends_clause_must_precede_implements_clause: { code: 1173, category: DiagnosticCategory.Error, key: "'extends' clause must precede 'implements' clause.", isEarly: true },
+        Classes_can_only_extend_a_single_class: { code: 1174, category: DiagnosticCategory.Error, key: "Classes can only extend a single class.", isEarly: true },
+        implements_clause_already_seen: { code: 1175, category: DiagnosticCategory.Error, key: "'implements' clause already seen.", isEarly: true },
+        Interface_declaration_cannot_have_implements_clause: { code: 1176, category: DiagnosticCategory.Error, key: "Interface declaration cannot have 'implements' clause.", isEarly: true },
         Binary_digit_expected: { code: 1177, category: DiagnosticCategory.Error, key: "Binary digit expected." },
         Octal_digit_expected: { code: 1178, category: DiagnosticCategory.Error, key: "Octal digit expected." },
         Unexpected_token_expected: { code: 1179, category: DiagnosticCategory.Error, key: "Unexpected token. '{' expected." },
         Property_destructuring_pattern_expected: { code: 1180, category: DiagnosticCategory.Error, key: "Property destructuring pattern expected." },
         Array_element_destructuring_pattern_expected: { code: 1181, category: DiagnosticCategory.Error, key: "Array element destructuring pattern expected." },
-        A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: DiagnosticCategory.Error, key: "A destructuring declaration must have an initializer." },
-        Destructuring_declarations_are_not_allowed_in_ambient_contexts: { code: 1183, category: DiagnosticCategory.Error, key: "Destructuring declarations are not allowed in ambient contexts." },
+        A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: DiagnosticCategory.Error, key: "A destructuring declaration must have an initializer.", isEarly: true },
+        Destructuring_declarations_are_not_allowed_in_ambient_contexts: { code: 1183, category: DiagnosticCategory.Error, key: "Destructuring declarations are not allowed in ambient contexts.", isEarly: true },
+        An_implementation_cannot_be_declared_in_ambient_contexts: { code: 1184, category: DiagnosticCategory.Error, key: "An implementation cannot be declared in ambient contexts.", isEarly: true },
         Merge_conflict_marker_encountered: { code: 1184, category: DiagnosticCategory.Error, key: "Merge conflict marker encountered." },
         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." },
@@ -435,8 +434,8 @@ module ts {
         _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." },
         You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." },
-        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." },
-        Computed_property_names_are_not_currently_supported: { code: 9002, category: DiagnosticCategory.Error, key: "Computed property names are not currently supported." },
+        yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported.", isEarly: true },
+        Generators_are_not_currently_supported: { code: 9001, category: DiagnosticCategory.Error, key: "Generators are not currently supported.", isEarly: true },
+        Computed_property_names_are_not_currently_supported: { code: 9002, category: DiagnosticCategory.Error, key: "Computed property names are not currently supported.", isEarly: true },
     };
 }
\ No newline at end of file
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 89b5d645ad1..e5c8ba1a258 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -9,7 +9,8 @@
     },
     "'{0}' expected.": {
         "category": "Error",
-        "code": 1005
+        "code": 1005,
+        "isEarly": true
     },
     "A file cannot have a reference to itself.": {
         "category": "Error",
@@ -17,7 +18,8 @@
     },
     "Trailing comma not allowed.": {
         "category": "Error",
-        "code": 1009
+        "code": 1009,
+        "isEarly": true
     },
     "'*/' expected.": {
         "category": "Error",
@@ -29,47 +31,58 @@
     },
     "Catch clause parameter cannot have a type annotation.": {
         "category": "Error",
-        "code": 1013
+        "code": 1013,
+        "isEarly": true
     },
     "A rest parameter must be last in a parameter list.": {
         "category": "Error",
-        "code": 1014
+        "code": 1014,
+        "isEarly": true
     },
     "Parameter cannot have question mark and initializer.": {
         "category": "Error",
-        "code": 1015
+        "code": 1015,
+        "isEarly": true
     },
     "A required parameter cannot follow an optional parameter.": {
         "category": "Error",
-        "code": 1016
+        "code": 1016,
+        "isEarly": true
     },
     "An index signature cannot have a rest parameter.": {
         "category": "Error",
-        "code": 1017
+        "code": 1017,
+        "isEarly": true
     },
     "An index signature parameter cannot have an accessibility modifier.": {
         "category": "Error",
-        "code": 1018
+        "code": 1018,
+        "isEarly": true
     },
     "An index signature parameter cannot have a question mark.": {
         "category": "Error",
-        "code": 1019
+        "code": 1019,
+        "isEarly": true
     },
     "An index signature parameter cannot have an initializer.": {
         "category": "Error",
-        "code": 1020
+        "code": 1020,
+        "isEarly": true
     },
     "An index signature must have a type annotation.": {
         "category": "Error",
-        "code": 1021
+        "code": 1021,
+        "isEarly": true
     },
     "An index signature parameter must have a type annotation.": {
         "category": "Error",
-        "code": 1022
+        "code": 1022,
+        "isEarly": true
     },
     "An index signature parameter type must be 'string' or 'number'.": {
         "category": "Error",
-        "code": 1023
+        "code": 1023,
+        "isEarly": true
     },
     "A class or interface declaration can only have one 'extends' clause.": {
         "category": "Error",
@@ -89,19 +102,23 @@
     },
     "Accessibility modifier already seen.": {
         "category": "Error",
-        "code": 1028
+        "code": 1028,
+        "isEarly": true
     },
     "'{0}' modifier must precede '{1}' modifier.": {
         "category": "Error",
-        "code": 1029
+        "code": 1029,
+        "isEarly": true
     },
     "'{0}' modifier already seen.": {
         "category": "Error",
-        "code": 1030
+        "code": 1030,
+        "isEarly": true
     },
     "'{0}' modifier cannot appear on a class element.": {
         "category": "Error",
-        "code": 1031
+        "code": 1031,
+        "isEarly": true
     },
     "An interface declaration cannot have an 'implements' clause.": {
         "category": "Error",
@@ -113,31 +130,33 @@
     },
     "Only ambient modules can use quoted names.": {
         "category": "Error",
-        "code": 1035
+        "code": 1035,
+        "isEarly": true
     },
     "Statements are not allowed in ambient contexts.": {
         "category": "Error",
-        "code": 1036
-    },
-    "A function implementation cannot be declared in an ambient context.": {
-        "category": "Error",
-        "code": 1037
+        "code": 1036,
+        "isEarly": true
     },
     "A 'declare' modifier cannot be used in an already ambient context.": {
         "category": "Error",
-        "code": 1038
+        "code": 1038,
+        "isEarly": true
     },
     "Initializers are not allowed in ambient contexts.": {
         "category": "Error",
-        "code": 1039
+        "code": 1039,
+        "isEarly": true
     },
     "'{0}' modifier cannot appear on a module element.": {
         "category": "Error",
-        "code": 1044
+        "code": 1044,
+        "isEarly": true
     },
     "A 'declare' modifier cannot be used with an interface declaration.": {
         "category": "Error",
-        "code": 1045
+        "code": 1045,
+        "isEarly": true
     },
     "A 'declare' modifier is required for a top level declaration in a .d.ts file.": {
         "category": "Error",
@@ -145,47 +164,58 @@
     },
     "A rest parameter cannot be optional.": {
         "category": "Error",
-        "code": 1047
+        "code": 1047,
+        "isEarly": true
     },
     "A rest parameter cannot have an initializer.": {
         "category": "Error",
-        "code": 1048
+        "code": 1048,
+        "isEarly": true
     },
     "A 'set' accessor must have exactly one parameter.": {
         "category": "Error",
-        "code": 1049
+        "code": 1049,
+        "isEarly": true
     },
     "A 'set' accessor cannot have an optional parameter.": {
         "category": "Error",
-        "code": 1051
+        "code": 1051,
+        "isEarly": true
     },
     "A 'set' accessor parameter cannot have an initializer.": {
         "category": "Error",
-        "code": 1052
+        "code": 1052,
+        "isEarly": true
     },
     "A 'set' accessor cannot have rest parameter.": {
         "category": "Error",
-        "code": 1053
+        "code": 1053,
+        "isEarly": true
     },
     "A 'get' accessor cannot have parameters.": {
         "category": "Error",
-        "code": 1054
+        "code": 1054,
+        "isEarly": true
     },
     "Accessors are only available when targeting ECMAScript 5 and higher.": {
         "category": "Error",
-        "code": 1056
+        "code": 1056,
+        "isEarly": true
     },
     "Enum member must have initializer.": {
         "category": "Error",
-        "code": 1061
+        "code": 1061,
+        "isEarly": true
     },
     "An export assignment cannot be used in an internal module.": {
         "category": "Error",
-        "code": 1063
+        "code": 1063,
+        "isEarly": true
     },
     "Ambient enum elements can only have integer literal initializers.": {
         "category": "Error",
-        "code": 1066
+        "code": 1066,
+        "isEarly": true
     },
     "Unexpected token. A constructor, method, accessor, or property was expected.": {
         "category": "Error",
@@ -193,7 +223,8 @@
     },
     "A 'declare' modifier cannot be used with an import declaration.": {
         "category": "Error",
-        "code": 1079
+        "code": 1079,
+        "isEarly":  true
     },
     "Invalid 'reference' directive syntax.": {
         "category": "Error",
@@ -201,143 +232,173 @@
     },
     "Octal literals are not available when targeting ECMAScript 5 and higher.": {
         "category": "Error",
-        "code": 1085
+        "code": 1085,
+        "isEarly": true
     },
     "An accessor cannot be declared in an ambient context.": {
         "category": "Error",
-        "code": 1086
+        "code": 1086,
+        "isEarly": true
     },
     "'{0}' modifier cannot appear on a constructor declaration.": {
         "category": "Error",
-        "code": 1089
+        "code": 1089,
+        "isEarly": true
     },
     "'{0}' modifier cannot appear on a parameter.": {
         "category": "Error",
-        "code": 1090
+        "code": 1090,
+        "isEarly": true
     },
     "Only a single variable declaration is allowed in a 'for...in' statement.": {
         "category": "Error",
-        "code": 1091
+        "code": 1091,
+        "isEarly": true
     },
     "Type parameters cannot appear on a constructor declaration.": {
         "category": "Error",
-        "code": 1092
+        "code": 1092,
+        "isEarly": true
     },
     "Type annotation cannot appear on a constructor declaration.": {
         "category": "Error",
-        "code": 1093
+        "code": 1093,
+        "isEarly": true
     },
     "An accessor cannot have type parameters.": {
         "category": "Error",
-        "code": 1094
+        "code": 1094,
+        "isEarly": true
     },
     "A 'set' accessor cannot have a return type annotation.": {
         "category": "Error",
-        "code": 1095
+        "code": 1095,
+        "isEarly": true
     },
     "An index signature must have exactly one parameter.": {
         "category": "Error",
-        "code": 1096
+        "code": 1096,
+        "isEarly": true
     },
     "'{0}' list cannot be empty.": {
         "category": "Error",
-        "code": 1097
+        "code": 1097,
+        "isEarly": true
     },
     "Type parameter list cannot be empty.": {
         "category": "Error",
-        "code": 1098
+        "code": 1098,
+        "isEarly": true
     },
     "Type argument list cannot be empty.": {
         "category": "Error",
-        "code": 1099
+        "code": 1099,
+        "isEarly": true
     },
     "Invalid use of '{0}' in strict mode.": {
         "category": "Error",
-        "code": 1100
+        "code": 1100,
+        "isEarly": true
     },
     "'with' statements are not allowed in strict mode.": {
         "category": "Error",
-        "code": 1101
+        "code": 1101,
+        "isEarly": true
     },
     "'delete' cannot be called on an identifier in strict mode.": {
         "category": "Error",
-        "code": 1102
+        "code": 1102,
+        "isEarly": true
     },
     "A 'continue' statement can only be used within an enclosing iteration statement.": {
         "category": "Error",
-        "code": 1104
+        "code": 1104,
+        "isEarly": true
     },
     "A 'break' statement can only be used within an enclosing iteration or switch statement.": {
         "category": "Error",
-        "code": 1105
+        "code": 1105,
+        "isEarly": true
     },
     "Jump target cannot cross function boundary.": {
         "category": "Error",
-        "code": 1107
+        "code": 1107,
+        "isEarly": true
     },
     "A 'return' statement can only be used within a function body.": {
         "category": "Error",
-        "code": 1108
+        "code": 1108,
+        "isEarly": true
     },
     "Expression expected.": {
         "category": "Error",
-        "code": 1109
+        "code": 1109,
+        "isEarly": true
     },
     "Type expected.": {
         "category": "Error",
-        "code": 1110
-    },
-    "A constructor implementation cannot be declared in an ambient context.": {
-        "category": "Error",
-        "code": 1111
+        "code": 1110,
+        "isEarly": true
     },
     "A class member cannot be declared optional.": {
         "category": "Error",
-        "code": 1112
+        "code": 1112,
+        "isEarly": true
     },
     "A 'default' clause cannot appear more than once in a 'switch' statement.": {
         "category": "Error",
-        "code": 1113
+        "code": 1113,
+        "isEarly": true
     },
     "Duplicate label '{0}'": {
         "category": "Error",
-        "code": 1114
+        "code": 1114,
+        "isEarly": true
     },
     "A 'continue' statement can only jump to a label of an enclosing iteration statement.": {
         "category": "Error",
-        "code": 1115
+        "code": 1115,
+        "isEarly": true
     },
     "A 'break' statement can only jump to a label of an enclosing statement.": {
         "category": "Error",
-        "code": 1116
+        "code": 1116,
+        "isEarly": true
     },
     "An object literal cannot have multiple properties with the same name in strict mode.": {
         "category": "Error",
-        "code": 1117
+        "code": 1117,
+        "isEarly": true
     },
     "An object literal cannot have multiple get/set accessors with the same name.": {
         "category": "Error",
-        "code": 1118
+        "code": 1118,
+        "isEarly": true
     },
     "An object literal cannot have property and accessor with the same name.": {
         "category": "Error",
-        "code": 1119
+        "code": 1119,
+        "isEarly": true
     },
     "An export assignment cannot have modifiers.": {
         "category": "Error",
-        "code": 1120
+        "code": 1120,
+        "isEarly": true
     },
     "Octal literals are not allowed in strict mode.": {
         "category": "Error",
-        "code": 1121
+        "code": 1121,
+        "isEarly": true
     },
     "A tuple type element list cannot be empty.": {
         "category": "Error",
-        "code": 1122
+        "code": 1122,
+        "isEarly": true
     },
     "Variable declaration list cannot be empty.": {
         "category": "Error",
-        "code": 1123
+        "code": 1123,
+        "isEarly": true
     },
     "Digit expected.": {
         "category": "Error",
@@ -385,7 +446,8 @@
     },
     "Argument expression expected.": {
         "category": "Error",
-        "code": 1135
+        "code": 1135,
+        "isEarly": true
     },
     "Property assignment expected.": {
         "category": "Error",
@@ -409,11 +471,13 @@
     },
     "String literal expected.": {
         "category": "Error",
-        "code": 1141
+        "code": 1141,
+        "isEarly": true
     },
     "Line break not permitted here.": {
         "category": "Error",
-        "code": 1142
+        "code": 1142,
+        "isEarly": true
     },
     "'{' or ';' expected.": {
         "category": "Error",
@@ -421,7 +485,8 @@
     },
     "Modifiers not permitted on index signature members.": {
         "category": "Error",
-        "code": 1145
+        "code": 1145,
+        "isEarly": true
     },
     "Declaration expected.": {
         "category": "Error",
@@ -429,7 +494,8 @@
     },
     "Import declarations in an internal module cannot reference an external module.": {
         "category": "Error",
-        "code": 1147
+        "code": 1147,
+        "isEarly": true
     },
     "Cannot compile external modules unless the '--module' flag is provided.": {
         "category": "Error",
@@ -441,7 +507,8 @@
     },
     "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.": {
         "category": "Error",
-        "code": 1150
+        "code": 1150,
+        "isEarly": true
     },
     "'var', 'let' or 'const' expected.": {
         "category": "Error",
@@ -449,27 +516,33 @@
     },
     "'let' declarations are only available when targeting ECMAScript 6 and higher.": {
         "category": "Error",
-        "code": 1153
+        "code": 1153,
+        "isEarly": true
     },
     "'const' declarations are only available when targeting ECMAScript 6 and higher.": {
         "category": "Error",
-        "code": 1154
+        "code": 1154,
+        "isEarly": true
     },
     "'const' declarations must be initialized": {
         "category": "Error",
-        "code": 1155
+        "code": 1155,
+        "isEarly": true
     },
     "'const' declarations can only be declared inside a block.": {
         "category": "Error",
-        "code": 1156
+        "code": 1156,
+        "isEarly": true
     },
     "'let' declarations can only be declared inside a block.": {
         "category": "Error",
-        "code": 1157
+        "code": 1157,
+        "isEarly": true
     },
     "Tagged templates are only available when targeting ECMAScript 6 and higher.": {
         "category": "Error",
-        "code": 1159
+        "code": 1159,
+        "isEarly": true
     },
     "Unterminated template literal.": {
         "category": "Error",
@@ -481,40 +554,48 @@
     },
     "An object member cannot be declared optional.": {
         "category": "Error",
-        "code": 1162
+        "code": 1162,
+        "isEarly": true
     },
-    "'yield' expression must be contained_within a generator declaration."
-    : {
+    "'yield' expression must be contained_within a generator declaration.": {
         "category": "Error",
-        "code": 1163
+        "code": 1163,
+        "isEarly": true
     },
     "Computed property names are not allowed in enums.": {
         "category": "Error",
-        "code": 1164
+        "code": 1164,
+        "isEarly": true
     },
     "Computed property names are not allowed in an ambient context.": {
         "category": "Error",
-        "code": 1165
+        "code": 1165,
+        "isEarly": true
     },
     "Computed property names are not allowed in class property declarations.": {
         "category": "Error",
-        "code": 1166
+        "code": 1166,
+        "isEarly": true
     },
     "Computed property names are only available when targeting ECMAScript 6 and higher.": {
         "category": "Error",
-        "code": 1167
+        "code": 1167,
+        "isEarly": true
     },
     "Computed property names are not allowed in method overloads.": {
         "category": "Error",
-        "code": 1168
+        "code": 1168,
+        "isEarly": true
     },
     "Computed property names are not allowed in interfaces.": {
         "category": "Error",
-        "code": 1169
+        "code": 1169,
+        "isEarly": true
     },
     "Computed property names are not allowed in type literals.": {
         "category": "Error",
-        "code": 1170
+        "code": 1170,
+        "isEarly": true
     },
     "A comma expression is not allowed in a computed property name.": {
         "category": "Error",
@@ -522,23 +603,28 @@
     },
     "'extends' clause already seen.": {
         "category": "Error",
-        "code": 1172
+        "code": 1172,
+        "isEarly": true
     },
     "'extends' clause must precede 'implements' clause.": {
         "category": "Error",
-        "code": 1173
+        "code": 1173,
+        "isEarly": true
     },
     "Classes can only extend a single class.": {
         "category": "Error",
-        "code": 1174
+        "code": 1174,
+        "isEarly": true
     },
     "'implements' clause already seen.": {
         "category": "Error",
-        "code": 1175
+        "code": 1175,
+        "isEarly": true
     },
     "Interface declaration cannot have 'implements' clause.": {
         "category": "Error",
-        "code": 1176
+        "code": 1176,
+        "isEarly": true
     },
     "Binary digit expected.": {
         "category": "Error",
@@ -562,11 +648,18 @@
     },
     "A destructuring declaration must have an initializer.": {
         "category": "Error",
-        "code": 1182
+        "code": 1182,
+        "isEarly": true
     },
     "Destructuring declarations are not allowed in ambient contexts.": {
         "category": "Error",
-        "code": 1183
+        "code": 1183,
+        "isEarly": true
+    },
+    "An implementation cannot be declared in ambient contexts.": {
+        "category": "Error",
+        "code": 1184,
+        "isEarly":  true
     },
     "Merge conflict marker encountered.": {
         "category": "Error",
@@ -1742,14 +1835,17 @@
     },
     "'yield' expressions are not currently supported.": {
         "category": "Error",
-        "code": 9000
+        "code": 9000,
+        "isEarly":  true
     },
     "Generators are not currently supported.": {
         "category": "Error",
-        "code": 9001
+        "code": 9001,
+        "isEarly":  true
     },
     "Computed property names are not currently supported.": {
         "category": "Error",
-        "code": 9002
+        "code": 9002,
+        "isEarly":  true
     }
 }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 14319b28257..d4dc86dd89e 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -13,7 +13,7 @@ module ts {
     export function createNode(kind: SyntaxKind): Node {
         return new (getNodeConstructor(kind))();
     }
-
+
     // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
     // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
     // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
@@ -49,7 +49,8 @@ module ts {
                     child((<QualifiedName>node).right);
             case SyntaxKind.TypeParameter:
                 return child((<TypeParameterDeclaration>node).name) ||
-                    child((<TypeParameterDeclaration>node).constraint);
+                    child((<TypeParameterDeclaration>node).constraint) ||
+                    child((<TypeParameterDeclaration>node).expression);
             case SyntaxKind.Parameter:
             case SyntaxKind.PropertyDeclaration:
             case SyntaxKind.PropertySignature:
@@ -387,8 +388,8 @@ module ts {
             case ParsingContext.HeritageClauses:        return Diagnostics.Unexpected_token_expected;
         }
     };
-
-    function modifierToFlag(token: SyntaxKind): NodeFlags {
+
+    export function modifierToFlag(token: SyntaxKind): NodeFlags {
         switch (token) {
             case SyntaxKind.StaticKeyword: return NodeFlags.Static;
             case SyntaxKind.PublicKeyword: return NodeFlags.Public;
@@ -423,7 +424,7 @@ module ts {
         forEachChild(sourceFile, walk);
     }
 
-    function isEvalOrArgumentsIdentifier(node: Node): boolean {
+    export function isEvalOrArgumentsIdentifier(node: Node): boolean {
         return node.kind === SyntaxKind.Identifier &&
             ((<Identifier>node).text === "eval" || (<Identifier>node).text === "arguments");
     }
@@ -771,7 +772,7 @@ module ts {
             if (token === SyntaxKind.YieldKeyword && inYieldContext()) {
                 return false;
             }
-            
+
             return inStrictModeContext() ? token > SyntaxKind.LastFutureReservedWord : token > SyntaxKind.LastReservedWord;
         }
 
@@ -947,7 +948,7 @@ module ts {
             parseExpected(SyntaxKind.CloseBracketToken);
             return finishNode(node);
         }
-        
+
         function parseContextualModifier(t: SyntaxKind): boolean {
             return token === t && tryParse(nextTokenCanFollowModifier);
         }
@@ -1028,7 +1029,7 @@ module ts {
             nextToken();
             return isIdentifier();
         }
-        
+
         function isNotHeritageClauseTypeName(): boolean {
             if (token === SyntaxKind.ImplementsKeyword ||
                 token === SyntaxKind.ExtendsKeyword) {
@@ -1300,12 +1301,12 @@ module ts {
 
             var templateSpans = <NodeArray<TemplateSpan>>[];
             templateSpans.pos = getNodePos();
-            
+
             do {
                 templateSpans.push(parseTemplateSpan());
             }
             while (templateSpans[templateSpans.length - 1].literal.kind === SyntaxKind.TemplateMiddle)
-            
+
             templateSpans.end = getNodeEnd();
             template.templateSpans = templateSpans;
 
@@ -1691,7 +1692,7 @@ module ts {
                     if (lookAhead(isStartOfConstructSignature)) {
                         return parseSignatureMember(SyntaxKind.ConstructSignature);
                     }
-                    // fall through.
+                // fall through.
                 case SyntaxKind.StringLiteral:
                 case SyntaxKind.NumericLiteral:
                     return parsePropertyOrMethodSignature();
@@ -2338,7 +2339,7 @@ module ts {
                 if (newPrecedence <= precedence) {
                     break;
                 }
-                
+
                 if (token === SyntaxKind.InKeyword && inDisallowInContext()) {
                     break;
                 }
@@ -2564,7 +2565,7 @@ module ts {
             // Because CallExpression and MemberExpression are left recursive, we need to bottom out
             // of the recursion immediately.  So we parse out a primary expression to start with.
             var expression = parsePrimaryExpression();
-            return parseMemberExpressionRest(expression); 
+            return parseMemberExpressionRest(expression);
         }
 
         function parseSuperExpression(): MemberExpression {
@@ -2692,7 +2693,7 @@ module ts {
                 ? typeArguments
                 : undefined;
         }
-        
+
         function canFollowTypeArgumentsInExpression(): boolean {
             switch (token) {
                 case SyntaxKind.OpenParenToken:                 // foo<x>(   
@@ -3260,7 +3261,7 @@ module ts {
                     if (isLetDeclaration()) {
                         return parseVariableStatement(scanner.getStartPos(), /*modifiers:*/ undefined);
                     }
-                    // Else parse it like identifier - fall through
+                // Else parse it like identifier - fall through
                 default:
                     return parseExpressionOrLabeledStatement();
             }
@@ -3517,7 +3518,7 @@ module ts {
                     modifiers.pos = modifierStart;
                 }
                 flags |= modifierToFlag(modifierKind);
-                modifiers.push(finishNode(createNode(modifierKind, modifierStart))); 
+                modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
             }
             if (modifiers) {
                 modifiers.flags = flags;
@@ -3695,9 +3696,9 @@ module ts {
 
         function parseModuleDeclaration(fullStart: number, modifiers: ModifiersArray): ModuleDeclaration {
             parseExpected(SyntaxKind.ModuleKeyword);
-            return token === SyntaxKind.StringLiteral 
+            return token === SyntaxKind.StringLiteral
                 ? parseAmbientExternalModuleDeclaration(fullStart, modifiers)
-                : parseInternalModuleTail(fullStart, modifiers, modifiers? modifiers.flags : 0);
+                : parseInternalModuleTail(fullStart, modifiers, modifiers ? modifiers.flags : 0);
         }
 
         function isExternalModuleReference() {
@@ -3753,7 +3754,7 @@ module ts {
             parseSemicolon();
             return finishNode(node);
         }
-        
+
         function isLetDeclaration() {
             // It is let declaration if in strict mode or next token is identifier on same line.
             // otherwise it needs to be treated like identifier
@@ -3767,7 +3768,7 @@ module ts {
                 case SyntaxKind.FunctionKeyword:
                     return true;
                 case SyntaxKind.LetKeyword:
-                    return isLetDeclaration(); 
+                    return isLetDeclaration();
                 case SyntaxKind.ClassKeyword:
                 case SyntaxKind.InterfaceKeyword:
                 case SyntaxKind.EnumKeyword:
@@ -3903,8 +3904,8 @@ module ts {
                 else {
                     var amdModuleNameRegEx = /^\/\/\/\s*<amd-module\s+name\s*=\s*('|")(.+?)\1/gim;
                     var amdModuleNameMatchResult = amdModuleNameRegEx.exec(comment);
-                    if(amdModuleNameMatchResult) {
-                        if(amdModuleName) {
+                    if (amdModuleNameMatchResult) {
+                        if (amdModuleName) {
                             sourceFile.referenceDiagnostics.push(createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments));
                         }
                         amdModuleName = amdModuleNameMatchResult[2];
@@ -3935,16 +3936,9 @@ module ts {
         var syntacticDiagnostics: Diagnostic[];
         function getSyntacticDiagnostics() {
             if (syntacticDiagnostics === undefined) {
-                if (sourceFile.parseDiagnostics.length > 0) {
-                    // Don't bother doing any grammar checks if there are already parser errors.  
-                    // Otherwise we may end up with too many cascading errors.
-                    syntacticDiagnostics = sourceFile.referenceDiagnostics.concat(sourceFile.parseDiagnostics);
-                }
-                else {
-                    // No parser errors were reported.  Perform our stricter grammar checks.
-                    checkGrammar(sourceText, languageVersion, sourceFile);
-                    syntacticDiagnostics = sourceFile.referenceDiagnostics.concat(sourceFile.grammarDiagnostics);
-                }
+                // Don't bother doing any grammar checks if there are already parser errors.  
+                // Otherwise we may end up with too many cascading errors.
+                syntacticDiagnostics = sourceFile.referenceDiagnostics.concat(sourceFile.parseDiagnostics);
             }
 
             Debug.assert(syntacticDiagnostics !== undefined);
@@ -3952,7 +3946,7 @@ module ts {
         }
     }
 
-    function isLeftHandSideExpression(expr: Expression): boolean {
+    export function isLeftHandSideExpression(expr: Expression): boolean {
         if (expr) {
             switch (expr.kind) {
                 case SyntaxKind.PropertyAccessExpression:
@@ -3982,1290 +3976,10 @@ module ts {
         return false;
     }
 
-    function isAssignmentOperator(token: SyntaxKind): boolean {
+    export function isAssignmentOperator(token: SyntaxKind): boolean {
         return token >= SyntaxKind.FirstAssignment && token <= SyntaxKind.LastAssignment;
     }
 
-    function checkGrammar(sourceText: string, languageVersion: ScriptTarget, file: SourceFile) {
-        var grammarDiagnostics = file.grammarDiagnostics;
-
-        // Create a scanner so we can find the start of tokens to report errors on.
-        var scanner = createScanner(languageVersion, /*skipTrivia*/ true, sourceText);
-
-        // We're automatically in an ambient context if this is a .d.ts file.
-        var inAmbientContext = fileExtensionIs(file.filename, ".d.ts");
-        var inFunctionBlock = false;
-        var parent: Node;
-        visitNode(file);
-
-        function visitNode(node: Node): void {
-            // Store and restore our recursive state here.
-            var savedParent = parent;
-            node.parent = parent;
-            parent = node;
-
-            if (!checkModifiers(node)) {
-                var savedInFunctionBlock = inFunctionBlock;
-                if (isFunctionBlock(node)) {
-                    inFunctionBlock = true;
-                }
-
-                var savedInAmbientContext = inAmbientContext
-                if (node.flags & NodeFlags.Ambient) {
-                    inAmbientContext = true;
-                }
-
-                checkNodeAndChildren(node);
-
-                inAmbientContext = savedInAmbientContext;
-                inFunctionBlock = savedInFunctionBlock;
-            }
-
-            parent = savedParent;
-        }
-
-        function checkNodeAndChildren(node: Node) {
-            var nodeKind = node.kind;
-            // First, check if you have a statement in a place where it is not allowed.  We want 
-            // to do this before recursing, because we'd prefer to report these errors at the top
-            // level instead of at some nested level.
-            if (inAmbientContext && checkForStatementInAmbientContext(node, nodeKind)) {
-                return;
-            }
-
-            // if we got any errors, just stop performing any more checks on this node or higher.
-            if (checkNode(node, nodeKind)) {
-                return;
-            }
-
-            // Otherwise, recurse and see if we have any errors below us.
-            forEachChild(node, visitNode);
-        }
-
-        function checkNode(node: Node, nodeKind: SyntaxKind): boolean {
-            // Now do node specific checks.
-            switch (nodeKind) {
-                case SyntaxKind.ArrowFunction:
-                case SyntaxKind.CallSignature:
-                case SyntaxKind.ConstructorType:
-                case SyntaxKind.ConstructSignature:
-                case SyntaxKind.FunctionType:
-                    return checkAnySignatureDeclaration(<FunctionLikeDeclaration>node);
-                case SyntaxKind.BreakStatement:
-                case SyntaxKind.ContinueStatement:
-                    return checkBreakOrContinueStatement(<BreakOrContinueStatement>node);
-                case SyntaxKind.CallExpression:
-                case SyntaxKind.NewExpression:
-                    return checkCallOrNewExpression(<NewExpression>node);
-
-                case SyntaxKind.EnumDeclaration:                return checkEnumDeclaration(<EnumDeclaration>node);
-                case SyntaxKind.BinaryExpression:               return checkBinaryExpression(<BinaryExpression>node);
-                case SyntaxKind.BindingElement:                 return checkBindingElement(<BindingElement>node);
-                case SyntaxKind.CatchClause:                    return checkCatchClause(<CatchClause>node);
-                case SyntaxKind.ClassDeclaration:               return checkClassDeclaration(<ClassDeclaration>node);
-                case SyntaxKind.ComputedPropertyName:           return checkComputedPropertyName(<ComputedPropertyName>node);
-                case SyntaxKind.Constructor:                    return checkConstructor(<ConstructorDeclaration>node);
-                case SyntaxKind.DeleteExpression:               return checkDeleteExpression(<DeleteExpression> node);
-                case SyntaxKind.ElementAccessExpression:        return checkElementAccessExpression(<ElementAccessExpression>node);
-                case SyntaxKind.ExportAssignment:               return checkExportAssignment(<ExportAssignment>node);
-                case SyntaxKind.ExternalModuleReference:        return checkExternalModuleReference(<ExternalModuleReference>node);
-                case SyntaxKind.ForInStatement:                 return checkForInStatement(<ForInStatement>node);
-                case SyntaxKind.ForStatement:                   return checkForStatement(<ForStatement>node);
-                case SyntaxKind.FunctionDeclaration:            return checkFunctionDeclaration(<FunctionLikeDeclaration>node);
-                case SyntaxKind.FunctionExpression:             return checkFunctionExpression(<FunctionExpression>node);
-                case SyntaxKind.GetAccessor:                    return checkGetAccessor(<MethodDeclaration>node);
-                case SyntaxKind.HeritageClause:                 return checkHeritageClause(<HeritageClause>node);
-                case SyntaxKind.IndexSignature:                 return checkIndexSignature(<SignatureDeclaration>node);
-                case SyntaxKind.InterfaceDeclaration:           return checkInterfaceDeclaration(<InterfaceDeclaration>node);
-                case SyntaxKind.LabeledStatement:               return checkLabeledStatement(<LabeledStatement>node);
-                case SyntaxKind.PropertyAssignment:             return checkPropertyAssignment(<PropertyAssignment>node);
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                    return checkMethod(<MethodDeclaration>node);
-                case SyntaxKind.ModuleDeclaration:              return checkModuleDeclaration(<ModuleDeclaration>node);
-                case SyntaxKind.ObjectLiteralExpression:        return checkObjectLiteralExpression(<ObjectLiteralExpression>node);
-                case SyntaxKind.NumericLiteral:                 return checkNumericLiteral(<LiteralExpression>node);
-                case SyntaxKind.Parameter:                      return checkParameter(<ParameterDeclaration>node);
-                case SyntaxKind.PostfixUnaryExpression:         return checkPostfixUnaryExpression(<PostfixUnaryExpression>node);
-                case SyntaxKind.PrefixUnaryExpression:          return checkPrefixUnaryExpression(<PrefixUnaryExpression>node);
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.PropertySignature:
-                    return checkProperty(<PropertyDeclaration>node);
-                case SyntaxKind.ReturnStatement:                return checkReturnStatement(<ReturnStatement>node);
-                case SyntaxKind.SetAccessor:                    return checkSetAccessor(<MethodDeclaration>node);
-                case SyntaxKind.SourceFile:                     return checkSourceFile(<SourceFile>node);
-                case SyntaxKind.ShorthandPropertyAssignment:    return checkShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);
-                case SyntaxKind.SwitchStatement:                return checkSwitchStatement(<SwitchStatement>node);
-                case SyntaxKind.TaggedTemplateExpression:       return checkTaggedTemplateExpression(<TaggedTemplateExpression>node);
-                case SyntaxKind.ThrowStatement:                 return checkThrowStatement(<ThrowStatement>node);
-                case SyntaxKind.TupleType:                      return checkTupleType(<TupleTypeNode>node);
-                case SyntaxKind.TypeParameter:                  return checkTypeParameter(<TypeParameterDeclaration>node);
-                case SyntaxKind.TypeReference:                  return checkTypeReference(<TypeReferenceNode>node);
-                case SyntaxKind.VariableDeclaration:            return checkVariableDeclaration(<VariableDeclaration>node);
-                case SyntaxKind.VariableStatement:              return checkVariableStatement(<VariableStatement>node);
-                case SyntaxKind.WithStatement:                  return checkWithStatement(<WithStatement>node);
-                case SyntaxKind.YieldExpression:                return checkYieldExpression(<YieldExpression>node);
-            }
-        }
-
-        function scanToken(pos: number) {
-            var start = skipTrivia(sourceText, pos);
-            scanner.setTextPos(start);
-            scanner.scan();
-            return start;
-        }
-
-        function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            var start = scanToken(node.pos);
-            grammarDiagnostics.push(createFileDiagnostic(file, start, scanner.getTextPos() - start, message, arg0, arg1, arg2));
-            return true;
-        }
-
-        function grammarErrorAfterFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            scanToken(node.pos);
-            grammarDiagnostics.push(createFileDiagnostic(file, scanner.getTextPos(), 0, message, arg0, arg1, arg2));
-            return true;
-        }
-
-        function grammarErrorOnNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            var span = getErrorSpanForNode(node);
-            var start = span.end > span.pos ? skipTrivia(file.text, span.pos) : span.pos;
-            var length = span.end - start;
-
-            grammarDiagnostics.push(createFileDiagnostic(file, start, length, message, arg0, arg1, arg2));
-            return true;
-        }
-
-        function grammarErrorAtPos(start: number, length: number, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            grammarDiagnostics.push(createFileDiagnostic(file, start, length, message, arg0, arg1, arg2));
-            return true;
-        }
-
-        function reportInvalidUseInStrictMode(node: Identifier): boolean {
-            // declarationNameToString cannot be used here since it uses a backreference to 'parent' that is not yet set
-            var name = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
-            return grammarErrorOnNode(node, Diagnostics.Invalid_use_of_0_in_strict_mode, name);
-        }
-
-        function checkForStatementInAmbientContext(node: Node, kind: SyntaxKind): boolean {
-            switch (kind) {
-                case SyntaxKind.Block:
-                case SyntaxKind.EmptyStatement:
-                case SyntaxKind.IfStatement:
-                case SyntaxKind.DoStatement:
-                case SyntaxKind.WhileStatement:
-                case SyntaxKind.ForStatement:
-                case SyntaxKind.ForInStatement:
-                case SyntaxKind.ContinueStatement:
-                case SyntaxKind.BreakStatement:
-                case SyntaxKind.ReturnStatement:
-                case SyntaxKind.WithStatement:
-                case SyntaxKind.SwitchStatement:
-                case SyntaxKind.ThrowStatement:
-                case SyntaxKind.TryStatement:
-                case SyntaxKind.DebuggerStatement:
-                case SyntaxKind.LabeledStatement:
-                case SyntaxKind.ExpressionStatement:
-                    return grammarErrorOnFirstToken(node, Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
-            }
-        }
-
-        function checkAnySignatureDeclaration(node: SignatureDeclaration): boolean {
-            return checkTypeParameterList(node.typeParameters) ||
-                checkParameterList(node.parameters);
-        }
-
-        function checkBinaryExpression(node: BinaryExpression) {
-            if (node.parserContextFlags & ParserContextFlags.StrictMode) {
-                if (isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operator)) {
-                    if (isEvalOrArgumentsIdentifier(node.left)) {
-                        // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an 
-                        // Assignment operator(11.13) or of a PostfixExpression(11.3)
-                        return reportInvalidUseInStrictMode(<Identifier>node.left);
-                    }
-                }
-            }
-        }
-
-        function isIterationStatement(node: Node, lookInLabeledStatements: boolean): boolean {
-            switch (node.kind) {
-                case SyntaxKind.ForStatement:
-                case SyntaxKind.ForInStatement:
-                case SyntaxKind.DoStatement:
-                case SyntaxKind.WhileStatement:
-                    return true;
-                case SyntaxKind.LabeledStatement:
-                    return lookInLabeledStatements && isIterationStatement((<LabeledStatement>node).statement, lookInLabeledStatements);
-            }
-
-            return false;
-        }
-
-        function checkLabeledStatement(node: LabeledStatement): boolean {
-            // ensure that label is unique
-            var current = node.parent;
-            while (current) {
-                if (isAnyFunction(current)) {
-                    break;
-                }
-                if (current.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>current).label.text === node.label.text) {
-                    return grammarErrorOnNode(node.label, Diagnostics.Duplicate_label_0, getTextOfNodeFromSourceText(sourceText, node.label));
-                }
-                current = current.parent;
-            }
-        }
-
-        function checkBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {
-            var current: Node = node;
-            while (current) {
-                if (isAnyFunction(current)) {
-                    return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);
-                }
-
-                switch (current.kind) {
-                    case SyntaxKind.LabeledStatement:
-                        if (node.label && (<LabeledStatement>current).label.text === node.label.text) {
-                            // found matching label - verify that label usage is correct
-                            // continue can only target labels that are on iteration statements
-                            var isMisplacedContinueLabel = node.kind === SyntaxKind.ContinueStatement
-                                && !isIterationStatement((<LabeledStatement>current).statement, /*lookInLabeledStatement*/ true);
-
-                            if (isMisplacedContinueLabel) {
-                                return grammarErrorOnNode(node, Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
-                            }
-
-                            return false;
-                        }
-                        break;
-                    case SyntaxKind.SwitchStatement:
-                        if (node.kind === SyntaxKind.BreakStatement && !node.label) {
-                            // unlabeled break within switch statement - ok
-                            return false;
-                        }
-                        break;
-                    default:
-                        if (isIterationStatement(current, /*lookInLabeledStatement*/ false) && !node.label) {
-                            // unlabeled break or continue within iteration statement - ok
-                            return false;
-                        }
-                        break;
-                }
-
-                current = current.parent;
-            }
-
-            if (node.label) {
-                var message = node.kind === SyntaxKind.BreakStatement
-                    ? Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement
-                    : Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
-
-                return grammarErrorOnNode(node, message)
-            }
-            else {
-                var message = node.kind === SyntaxKind.BreakStatement
-                    ? Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement
-                    : Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
-                return grammarErrorOnNode(node, message)
-            }
-        }
-
-        function checkCallOrNewExpression(node: CallExpression) {
-            return checkTypeArguments(node.typeArguments) ||
-                checkArguments(node.arguments);
-        }
-
-        function checkArguments(arguments: NodeArray<Expression>) {
-            return checkForDisallowedTrailingComma(arguments) ||
-                checkForOmittedArgument(arguments);
-        }
-
-        function checkTypeArguments(typeArguments: NodeArray<TypeNode>) {
-            return checkForDisallowedTrailingComma(typeArguments) ||
-                checkForAtLeastOneTypeArgument(typeArguments);
-        }
-
-        function checkForOmittedArgument(arguments: NodeArray<Expression>) {
-            if (arguments) {
-                for (var i = 0, n = arguments.length; i < n; i++) {
-                    var arg = arguments[i];
-                    if (arg.kind === SyntaxKind.OmittedExpression) {
-                        return grammarErrorAtPos(arg.pos, 0, Diagnostics.Argument_expression_expected);
-                    }
-                }
-            }
-        }
-
-        function checkForAtLeastOneTypeArgument(typeArguments: NodeArray<TypeNode>) {
-            if (typeArguments && typeArguments.length === 0) {
-                var start = typeArguments.pos - "<".length;
-                var end = skipTrivia(sourceText, typeArguments.end) + ">".length;
-                return grammarErrorAtPos(start, end - start, Diagnostics.Type_argument_list_cannot_be_empty);
-            }
-        }
-
-        function checkForDisallowedTrailingComma(list: NodeArray<Node>): boolean {
-            if (list && list.hasTrailingComma) {
-                var start = list.end - ",".length;
-                var end = list.end;
-                return grammarErrorAtPos(start, end - start, Diagnostics.Trailing_comma_not_allowed);
-            }
-        }
-
-        function checkCatchClause(node: CatchClause) {
-            if (node.type) {
-                var colonStart = skipTrivia(sourceText, node.name.end);
-                return grammarErrorAtPos(colonStart, ":".length, Diagnostics.Catch_clause_parameter_cannot_have_a_type_annotation);
-            }
-            if (node.parserContextFlags & ParserContextFlags.StrictMode && isEvalOrArgumentsIdentifier(node.name)) {
-                // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the 
-                // Catch production is eval or arguments
-                return reportInvalidUseInStrictMode(node.name);
-            }
-        }
-
-        function checkClassDeclaration(node: ClassDeclaration) {
-            return checkClassDeclarationHeritageClauses(node);
-        }
-
-        function checkClassDeclarationHeritageClauses(node: ClassDeclaration): boolean {
-            var seenExtendsClause = false;
-            var seenImplementsClause = false;
-
-            if (node.heritageClauses) {
-                for (var i = 0, n = node.heritageClauses.length; i < n; i++) {
-                    Debug.assert(i <= 2);
-                    var heritageClause = node.heritageClauses[i];
-
-                    if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
-                        if (seenExtendsClause) {
-                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
-                        }
-
-                        if (seenImplementsClause) {
-                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_must_precede_implements_clause);
-                        }
-
-                        if (heritageClause.types.length > 1) {
-                            return grammarErrorOnFirstToken(heritageClause.types[1], Diagnostics.Classes_can_only_extend_a_single_class);
-                        }
-
-                        seenExtendsClause = true;
-                    }
-                    else {
-                        Debug.assert(heritageClause.token === SyntaxKind.ImplementsKeyword);
-                        if (seenImplementsClause) {
-                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.implements_clause_already_seen);
-                        }
-
-                        seenImplementsClause = true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        function checkForAtLeastOneHeritageClause(types: NodeArray<TypeNode>, listType: string): boolean {
-            if (types && types.length === 0) {
-                return grammarErrorAtPos(types.pos, 0, Diagnostics._0_list_cannot_be_empty, listType)
-            }
-        }
-
-        function checkConstructor(node: ConstructorDeclaration) {
-            return checkAnySignatureDeclaration(node) ||
-                checkConstructorTypeParameters(node) ||
-                checkConstructorTypeAnnotation(node) ||
-                checkForBodyInAmbientContext(node.body, /*isConstructor:*/ true);
-        }
-
-        function checkConstructorTypeParameters(node: ConstructorDeclaration) {
-            if (node.typeParameters) {
-                return grammarErrorAtPos(node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
-            }
-        }
-
-        function checkConstructorTypeAnnotation(node: ConstructorDeclaration) {
-            if (node.type) {
-                return grammarErrorOnNode(node.type, Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
-            }
-        }
-
-        function checkDeleteExpression(node: DeleteExpression) {
-            if (node.parserContextFlags & ParserContextFlags.StrictMode && node.expression.kind === SyntaxKind.Identifier) {
-                // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its 
-                // UnaryExpression is a direct reference to a variable, function argument, or function name
-                return grammarErrorOnNode(node.expression, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode);
-            }
-        }
-
-        function checkEnumDeclaration(enumDecl: EnumDeclaration): boolean {
-            var enumIsConst = (enumDecl.flags & NodeFlags.Const) !== 0;
-
-            var hasError = false;
-
-            // skip checks below for const enums  - they allow arbitrary initializers as long as they can be evaluated to constant expressions.
-            // since all values are known in compile time - it is not necessary to check that constant enum section precedes computed enum members.
-            if (!enumIsConst) {
-                var inConstantEnumMemberSection = true;
-                for (var i = 0, n = enumDecl.members.length; i < n; i++) {
-                    var node = enumDecl.members[i];
-                    if (node.name.kind === SyntaxKind.ComputedPropertyName) {
-                        hasError = grammarErrorOnNode(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
-                    }
-                    else if (inAmbientContext) {
-                        if (node.initializer && !isIntegerLiteral(node.initializer)) {
-                            hasError = grammarErrorOnNode(node.name, Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers) || hasError;
-                        }
-                    }
-                    else if (node.initializer) {
-                        inConstantEnumMemberSection = isIntegerLiteral(node.initializer);
-                    }
-                    else if (!inConstantEnumMemberSection) {
-                        hasError = grammarErrorOnNode(node.name, Diagnostics.Enum_member_must_have_initializer) || hasError;
-                    }
-                }
-            }
-
-            return hasError;
-        }
-
-        function isIntegerLiteral(expression: Expression): boolean {
-            function isInteger(literalExpression: LiteralExpression): boolean {
-                // Allows for scientific notation since literalExpression.text was formed by
-                // coercing a number to a string. Sometimes this coercion can yield a string
-                // in scientific notation.
-                // We also don't need special logic for hex because a hex integer is converted
-                // to decimal when it is coerced.
-                return /^[0-9]+([eE]\+?[0-9]+)?$/.test(literalExpression.text);
-            }
-
-            if (expression.kind === SyntaxKind.PrefixUnaryExpression) {
-                var unaryExpression = <PrefixUnaryExpression>expression;
-                if (unaryExpression.operator === SyntaxKind.PlusToken || unaryExpression.operator === SyntaxKind.MinusToken) {
-                    expression = unaryExpression.operand;
-                }
-            }
-            if (expression.kind === SyntaxKind.NumericLiteral) {
-                return isInteger(<LiteralExpression>expression);
-            }
-
-            return false;
-        }
-
-        function checkExportAssignment(node: ExportAssignment) {
-            if (node.flags & NodeFlags.Modifier) {
-                return grammarErrorOnFirstToken(node, Diagnostics.An_export_assignment_cannot_have_modifiers);
-            }
-        }
-
-        function checkExternalModuleReference(node: ExternalModuleReference) {
-            if (node.expression.kind !== SyntaxKind.StringLiteral) {
-                return grammarErrorOnNode(node.expression, Diagnostics.String_literal_expected);
-            }
-        }
-
-        function checkForInStatement(node: ForInStatement) {
-            return checkVariableDeclarations(node.declarations) ||
-                checkForMoreThanOneDeclaration(node.declarations);
-        }
-
-        function checkForStatement(node: ForStatement) {
-            return checkVariableDeclarations(node.declarations);
-        }
-
-        function checkForMoreThanOneDeclaration(declarations: NodeArray<VariableDeclaration>) {
-            if (declarations && declarations.length > 1) {
-                return grammarErrorOnFirstToken(declarations[1], Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement);
-            }
-        }
-
-        function checkFunctionDeclaration(node: FunctionLikeDeclaration) {
-            return checkAnySignatureDeclaration(node) ||
-                checkFunctionName(node.name) ||
-                checkForBodyInAmbientContext(node.body, /*isConstructor:*/ false) ||
-                checkForGenerator(node);
-        }
-
-        function checkForGenerator(node: FunctionLikeDeclaration) {
-            if (node.asteriskToken) {
-                return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_not_currently_supported);
-            }
-        }
-
-        function checkFunctionExpression(node: FunctionExpression) {
-            return checkAnySignatureDeclaration(node) ||
-                checkFunctionName(node.name) ||
-                checkForGenerator(node);
-        }
-
-        function checkFunctionName(name: Node) {
-            if (name && name.parserContextFlags & ParserContextFlags.StrictMode && isEvalOrArgumentsIdentifier(name)) {
-                // It is a SyntaxError to use within strict mode code the identifiers eval or arguments as the 
-                // Identifier of a FunctionLikeDeclaration or FunctionExpression or as a formal parameter name(13.1)
-                return reportInvalidUseInStrictMode(<Identifier>name);
-            }
-        }
-
-        function checkGetAccessor(node: MethodDeclaration) {
-            return checkAnySignatureDeclaration(node) ||
-                checkAccessor(node);
-        }
-
-        function checkElementAccessExpression(node: ElementAccessExpression) {
-            if (!node.argumentExpression) {
-                if (node.parent.kind === SyntaxKind.NewExpression && (<NewExpression>node.parent).expression === node) {
-                    var start = skipTrivia(sourceText, node.expression.end);
-                    var end = node.end;
-                    return grammarErrorAtPos(start, end - start, Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
-                }
-                else {
-                    var start = node.end - "]".length;
-                    var end = node.end;
-                    return grammarErrorAtPos(start, end - start, Diagnostics.Expression_expected);
-                }
-            }
-        }
-
-        function checkHeritageClause(node: HeritageClause): boolean {
-            return checkForDisallowedTrailingComma(node.types) ||
-                checkForAtLeastOneHeritageClause(node.types, tokenToString(node.token));
-        }
-
-        function checkIndexSignature(node: SignatureDeclaration): boolean {
-            return checkIndexSignatureParameters(node) ||
-                checkForIndexSignatureModifiers(node);
-        }
-
-        function checkForIndexSignatureModifiers(node: SignatureDeclaration): boolean {
-            if (node.flags & NodeFlags.Modifier) {
-                return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_not_permitted_on_index_signature_members);
-            }
-        }
-
-        function checkIndexSignatureParameters(node: SignatureDeclaration): boolean {
-            var parameter = node.parameters[0];
-            if (node.parameters.length !== 1) {
-                if (parameter) {
-                    return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
-                }
-                else {
-                    return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
-                }
-            }
-            else if (parameter.dotDotDotToken) {
-                return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
-            }
-            else if (parameter.flags & NodeFlags.Modifier) {
-                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
-            }
-            else if (parameter.questionToken) {
-                return grammarErrorOnNode(parameter.questionToken, Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
-            }
-            else if (parameter.initializer) {
-                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
-            }
-            else if (!parameter.type) {
-                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
-            }
-            else if (parameter.type.kind !== SyntaxKind.StringKeyword && parameter.type.kind !== SyntaxKind.NumberKeyword) {
-                return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_type_must_be_string_or_number);
-            }
-            else if (!node.type) {
-                return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_a_type_annotation);
-            }
-        }
-
-        function checkInterfaceDeclaration(node: InterfaceDeclaration) {
-            return checkInterfaceDeclarationHeritageClauses(node);
-        }
-
-        function checkInterfaceDeclarationHeritageClauses(node: InterfaceDeclaration): boolean {
-            var seenExtendsClause = false;
-
-            if (node.heritageClauses) {
-                for (var i = 0, n = node.heritageClauses.length; i < n; i++) {
-                    Debug.assert(i <= 1);
-                    var heritageClause = node.heritageClauses[i];
-
-                    if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
-                        if (seenExtendsClause) {
-                            return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
-                        }
-
-                        seenExtendsClause = true;
-                    }
-                    else {
-                        Debug.assert(heritageClause.token === SyntaxKind.ImplementsKeyword);
-                        return grammarErrorOnFirstToken(heritageClause, Diagnostics.Interface_declaration_cannot_have_implements_clause);
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        function checkMethod(node: MethodDeclaration) {
-            if (checkAnySignatureDeclaration(node) ||
-                checkForBodyInAmbientContext(node.body, /*isConstructor:*/ false) ||
-                checkForGenerator(node)) {
-                return true;
-            }
-
-            if (node.parent.kind === SyntaxKind.ClassDeclaration) {
-                if (checkForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional)) {
-                    return true;
-                }
-                // Technically, computed properties in ambient contexts is disallowed 
-                // for property declarations and accessors too, not just methods.
-                // However, property declarations disallow computed names in general,
-                // and accessors are not allowed in ambient contexts in general,
-                // so this error only really matters for methods.
-                if (inAmbientContext) {
-                    return checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_an_ambient_context);
-                }
-                else if (!node.body) {
-                    return checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_method_overloads);
-                }
-            }
-            else if (node.parent.kind === SyntaxKind.InterfaceDeclaration) {
-                return checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_interfaces);
-            }
-            else if (node.parent.kind === SyntaxKind.TypeLiteral) {
-                return checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_type_literals);
-            }
-        }
-
-        function checkForBodyInAmbientContext(body: Block | Expression, isConstructor: boolean): boolean {
-            if (inAmbientContext && body && body.kind === SyntaxKind.Block) {
-                var diagnostic = isConstructor
-                    ? Diagnostics.A_constructor_implementation_cannot_be_declared_in_an_ambient_context
-                    : Diagnostics.A_function_implementation_cannot_be_declared_in_an_ambient_context;
-                return grammarErrorOnFirstToken(body, diagnostic);
-            }
-        }
-
-        function checkModuleDeclaration(node: ModuleDeclaration): boolean {
-            return checkModuleDeclarationName(node) ||
-                checkModuleDeclarationStatements(node);
-        }
-        
-        function checkModuleDeclarationName(node: ModuleDeclaration) {
-            if (!inAmbientContext && node.name.kind === SyntaxKind.StringLiteral) {
-                return grammarErrorOnNode(node.name, Diagnostics.Only_ambient_modules_can_use_quoted_names);
-            }
-        }
-
-        function checkModuleDeclarationStatements(node: ModuleDeclaration): boolean {
-            if (node.name.kind === SyntaxKind.Identifier && node.body.kind === SyntaxKind.ModuleBlock) {
-                var statements = (<ModuleBlock>node.body).statements;
-                for (var i = 0, n = statements.length; i < n; i++) {
-                    var statement = statements[i];
-
-                    if (statement.kind === SyntaxKind.ExportAssignment) {
-                        // Export assignments are not allowed in an internal module
-                        return grammarErrorOnNode(statement, Diagnostics.An_export_assignment_cannot_be_used_in_an_internal_module);
-                    }
-                    else if (isExternalModuleImportDeclaration(statement)) {
-                        return grammarErrorOnNode(getExternalModuleImportDeclarationExpression(statement), Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module);
-                    }
-                }
-            }
-        }
-
-        function checkObjectLiteralExpression(node: ObjectLiteralExpression): boolean {
-            var seen: Map<SymbolFlags> = {};
-            var Property = 1;
-            var GetAccessor = 2;
-            var SetAccesor = 4;
-            var GetOrSetAccessor = GetAccessor | SetAccesor;
-            var inStrictMode = (node.parserContextFlags & ParserContextFlags.StrictMode) !== 0;
-
-            for (var i = 0, n = node.properties.length; i < n; i++) {
-                var prop = <Declaration>node.properties[i];
-                var name = <Identifier>prop.name;
-                if (prop.kind === SyntaxKind.OmittedExpression || name.kind === SyntaxKind.ComputedPropertyName) {
-                    continue;
-                }
-
-                // ECMA-262 11.1.5 Object Initialiser 
-                // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
-                // a.This production is contained in strict code and IsDataDescriptor(previous) is true and 
-                // IsDataDescriptor(propId.descriptor) is true.
-                //    b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true.
-                //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
-                //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true 
-                // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields 
-                var currentKind: number;
-                if (prop.kind === SyntaxKind.PropertyAssignment ||
-                    prop.kind === SyntaxKind.ShorthandPropertyAssignment ||
-                    prop.kind === SyntaxKind.MethodDeclaration) {
-                    currentKind = Property;
-                }
-                else if (prop.kind === SyntaxKind.GetAccessor) {
-                    currentKind = GetAccessor;
-                }
-                else if (prop.kind === SyntaxKind.SetAccessor) {
-                    currentKind = SetAccesor;
-                }
-                else {
-                    Debug.fail("Unexpected syntax kind:" + prop.kind);
-                }
-
-                if (!hasProperty(seen, name.text)) {
-                    seen[name.text] = currentKind;
-                }
-                else {
-                    var existingKind = seen[name.text];
-                    if (currentKind === Property && existingKind === Property) {
-                        if (inStrictMode) {
-                            grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode);
-                        }
-                    }
-                    else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) {
-                        if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) {
-                            seen[name.text] = currentKind | existingKind;
-                        }
-                        else {
-                            return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
-                        }
-                    }
-                    else {
-                        return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
-                    }
-                }
-            }
-        }
-
-        function checkNumericLiteral(node: LiteralExpression): boolean {
-            if (node.flags & NodeFlags.OctalLiteral) {
-                if (node.parserContextFlags & ParserContextFlags.StrictMode) {
-                    return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode);
-                }
-                else if (languageVersion >= ScriptTarget.ES5) {
-                    return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
-                }
-            }
-        }
-
-        function checkModifiers(node: Node): boolean {
-            switch (node.kind) {
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.PropertySignature:
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                case SyntaxKind.IndexSignature:
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.InterfaceDeclaration:
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.EnumDeclaration:
-                case SyntaxKind.ExportAssignment:
-                case SyntaxKind.VariableStatement:
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.TypeAliasDeclaration:
-                case SyntaxKind.ImportDeclaration:
-                case SyntaxKind.Parameter:
-                    break;
-                default:
-                    return false;
-            }
-
-            if (!node.modifiers) {
-                return;
-            }
-
-            var lastStatic: Node, lastPrivate: Node, lastProtected: Node, lastDeclare: Node;
-            var flags = 0;
-            for (var i = 0, n = node.modifiers.length; i < n; i++) {
-                var modifier = node.modifiers[i];
-
-                switch (modifier.kind) {
-                    case SyntaxKind.PublicKeyword:
-                    case SyntaxKind.ProtectedKeyword:
-                    case SyntaxKind.PrivateKeyword:
-                        var text: string;
-                        if (modifier.kind === SyntaxKind.PublicKeyword) {
-                            text = "public";
-                        }
-                        else if (modifier.kind === SyntaxKind.ProtectedKeyword) {
-                            text = "protected";
-                            lastProtected = modifier;
-                        }
-                        else {
-                            text = "private";
-                            lastPrivate = modifier;
-                        }
-
-                        if (flags & NodeFlags.AccessibilityModifier) {
-                            return grammarErrorOnNode(modifier, Diagnostics.Accessibility_modifier_already_seen);
-                        }
-                        else if (flags & NodeFlags.Static) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
-                        }
-                        else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, text);
-                        }
-                        flags |= modifierToFlag(modifier.kind);
-                        break;
-
-                    case SyntaxKind.StaticKeyword:
-                        if (flags & NodeFlags.Static) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static");
-                        }
-                        else if (node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static");
-                        }
-                        else if (node.kind === SyntaxKind.Parameter) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
-                        }
-                        flags |= NodeFlags.Static;
-                        lastStatic = modifier;
-                        break;
-
-                    case SyntaxKind.ExportKeyword:
-                        if (flags & NodeFlags.Export) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export");
-                        }
-                        else if (flags & NodeFlags.Ambient) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
-                        }
-                        else if (node.parent.kind === SyntaxKind.ClassDeclaration) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export");
-                        }
-                        else if (node.kind === SyntaxKind.Parameter) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
-                        }
-                        flags |= NodeFlags.Export;
-                        break;
-
-                    case SyntaxKind.DeclareKeyword:
-                        if (flags & NodeFlags.Ambient) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");
-                        }
-                        else if (node.parent.kind === SyntaxKind.ClassDeclaration) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare");
-                        }
-                        else if (node.kind === SyntaxKind.Parameter) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
-                        }
-                        else if (inAmbientContext && node.parent.kind === SyntaxKind.ModuleBlock) {
-                            return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
-                        }
-                        flags |= NodeFlags.Ambient;
-                        lastDeclare = modifier;
-                        break;
-                }
-            }
-
-            if (node.kind === SyntaxKind.Constructor) {
-                if (flags & NodeFlags.Static) {
-                    return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
-                }
-                else if (flags & NodeFlags.Protected) {
-                    return grammarErrorOnNode(lastProtected, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected");
-                }
-                else if (flags & NodeFlags.Private) {
-                    return grammarErrorOnNode(lastPrivate, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private");
-                }
-            }
-            else if (node.kind === SyntaxKind.ImportDeclaration && flags & NodeFlags.Ambient) {
-                return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare");
-            }
-            else if (node.kind === SyntaxKind.InterfaceDeclaration && flags & NodeFlags.Ambient) {
-                return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare");
-            }
-        }
-
-        function checkParameter(node: ParameterDeclaration): boolean {
-            // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the 
-            // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code 
-            // or if its FunctionBody is strict code(11.1.5).
-            // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a 
-            // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) 
-            if (node.parserContextFlags & ParserContextFlags.StrictMode && isEvalOrArgumentsIdentifier(node.name)) {
-                return reportInvalidUseInStrictMode(<Identifier>node.name);
-            }
-        }
-
-        function checkTypeParameterList(typeParameters: NodeArray<TypeParameterDeclaration>): boolean {
-            if (checkForDisallowedTrailingComma(typeParameters)) {
-                return true;
-            }
-
-            if (typeParameters && typeParameters.length === 0) {
-                var start = typeParameters.pos - "<".length;
-                var end = skipTrivia(sourceText, typeParameters.end) + ">".length;
-                return grammarErrorAtPos(start, end - start, Diagnostics.Type_parameter_list_cannot_be_empty);
-            }
-        }
-
-        function checkParameterList(parameters: NodeArray<ParameterDeclaration>): boolean {
-            if (checkForDisallowedTrailingComma(parameters)) {
-                return true;
-            }
-
-            var seenOptionalParameter = false;
-            var parameterCount = parameters.length;
-
-            for (var i = 0; i < parameterCount; i++) {
-                var parameter = parameters[i];
-                if (parameter.dotDotDotToken) {
-                    if (i !== (parameterCount - 1)) {
-                        return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
-                    }
-
-                    if (parameter.questionToken) {
-                        return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_rest_parameter_cannot_be_optional);
-                    }
-
-                    if (parameter.initializer) {
-                        return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_parameter_cannot_have_an_initializer);
-                    }
-                }
-                else if (parameter.questionToken || parameter.initializer) {
-                    seenOptionalParameter = true;
-
-                    if (parameter.questionToken && parameter.initializer) {
-                        return grammarErrorOnNode(parameter.name, Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
-                    }
-                }
-                else {
-                    if (seenOptionalParameter) {
-                        return grammarErrorOnNode(parameter.name, Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
-                    }
-                }
-            }
-        }
-
-        function checkPostfixUnaryExpression(node: PostfixUnaryExpression) {
-            // The identifier eval or arguments may not appear as the LeftHandSideExpression of an 
-            // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression 
-            // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator. 
-            if (node.parserContextFlags & ParserContextFlags.StrictMode && isEvalOrArgumentsIdentifier(node.operand)) {
-                return reportInvalidUseInStrictMode(<Identifier>node.operand);
-            }
-        }
-
-        function checkPrefixUnaryExpression(node: PrefixUnaryExpression) {
-            if (node.parserContextFlags & ParserContextFlags.StrictMode) {
-                // The identifier eval or arguments may not appear as the LeftHandSideExpression of an 
-                // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression 
-                // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator
-                if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) && isEvalOrArgumentsIdentifier(node.operand)) {
-                    return reportInvalidUseInStrictMode(<Identifier>node.operand);
-                }
-            }
-        }
-
-        function checkProperty(node: PropertyDeclaration) {
-            if (node.parent.kind === SyntaxKind.ClassDeclaration) {
-                if (checkForInvalidQuestionMark(node, node.questionToken, Diagnostics.A_class_member_cannot_be_declared_optional) ||
-                    checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_class_property_declarations)) {
-                    return true;
-                }
-            }
-            else if (node.parent.kind === SyntaxKind.InterfaceDeclaration) {
-                if (checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_interfaces)) {
-                    return true;
-                }
-            }
-            else if (node.parent.kind === SyntaxKind.TypeLiteral) {
-                if (checkForDisallowedComputedProperty(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_type_literals)) {
-                    return true;
-                }
-            }
-
-            return checkForInitializerInAmbientContext(node);
-        }
-
-        function checkComputedPropertyName(node: ComputedPropertyName) {
-            // Since computed properties are not supported in the type checker, disallow them in TypeScript 1.4
-            // Once full support is added, remove this error.
-            return grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_not_currently_supported);
-            
-            if (languageVersion < ScriptTarget.ES6) {
-                return grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher);
-            }
-            else if (node.expression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>node.expression).operator === SyntaxKind.CommaToken) {
-                return grammarErrorOnNode(node.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
-            }
-        }
-
-        function checkForDisallowedComputedProperty(node: DeclarationName, message: DiagnosticMessage) {
-            if (node.kind === SyntaxKind.ComputedPropertyName) {
-                return grammarErrorOnNode(node, message);
-            }
-        }
-
-        function checkForInitializerInAmbientContext(node: PropertyDeclaration) {
-            if (inAmbientContext && node.initializer) {
-                return grammarErrorOnFirstToken(node.initializer, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
-            }
-        }
-
-        function checkPropertyAssignment(node: PropertyAssignment) {
-            return checkForInvalidQuestionMark(node, node.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional);
-        }
-
-        function checkForInvalidQuestionMark(node: Declaration, questionToken: Node, message: DiagnosticMessage) {
-            if (questionToken) {
-                return grammarErrorOnNode(questionToken, message);
-            }
-        }
-
-        function checkReturnStatement(node: ReturnStatement) {
-            if (!inFunctionBlock) {
-                return grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
-            }
-        }
-
-        function checkSetAccessor(node: MethodDeclaration) {
-            return checkAnySignatureDeclaration(node) ||
-                checkAccessor(node);
-        }
-
-        function checkAccessor(accessor: MethodDeclaration): boolean {
-            var kind = accessor.kind;
-            if (languageVersion < ScriptTarget.ES5) {
-                return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
-            }
-            else if (inAmbientContext) {
-                return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_be_declared_in_an_ambient_context);
-            }
-            else if (accessor.body === undefined) {
-                return grammarErrorAtPos(accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
-            }
-            else if (accessor.typeParameters) {
-                return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_have_type_parameters);
-            }
-            else if (kind === SyntaxKind.GetAccessor && accessor.parameters.length) {
-                return grammarErrorOnNode(accessor.name, Diagnostics.A_get_accessor_cannot_have_parameters);
-            }
-            else if (kind === SyntaxKind.SetAccessor) {
-                if (accessor.type) {
-                    return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
-                }
-                else if (accessor.parameters.length !== 1) {
-                    return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
-                }
-                else {
-                    var parameter = accessor.parameters[0];
-                    if (parameter.dotDotDotToken) {
-                        return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_set_accessor_cannot_have_rest_parameter);
-                    }
-                    else if (parameter.flags & NodeFlags.Modifier) {
-                        return grammarErrorOnNode(accessor.name, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
-                    }
-                    else if (parameter.questionToken) {
-                        return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
-                    }
-                    else if (parameter.initializer) {
-                        return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
-                    }
-                }
-            }
-        }
-
-        function checkSourceFile(node: SourceFile): boolean {
-            return inAmbientContext && checkTopLevelElementsForRequiredDeclareModifier(file);
-        }
-
-        function checkTopLevelElementsForRequiredDeclareModifier(file: SourceFile): boolean {
-            for (var i = 0, n = file.statements.length; i < n; i++) {
-                var decl = file.statements[i];
-                if (isDeclaration(decl) || decl.kind === SyntaxKind.VariableStatement) {
-                    if (checkTopLevelElementForRequiredDeclareModifier(decl)) {
-                        return true;
-                    }
-                }
-            }
-        }
-
-        function checkTopLevelElementForRequiredDeclareModifier(node: Node): boolean {
-            // A declare modifier is required for any top level .d.ts declaration except export=, interfaces and imports:
-            // categories:
-            //
-            //  DeclarationElement:
-            //     ExportAssignment
-            //     export_opt   InterfaceDeclaration
-            //     export_opt   ImportDeclaration
-            //     export_opt   ExternalImportDeclaration
-            //     export_opt   AmbientDeclaration
-            //
-            if (node.kind === SyntaxKind.InterfaceDeclaration ||
-                node.kind === SyntaxKind.ImportDeclaration ||
-                node.kind === SyntaxKind.ExportAssignment ||
-                (node.flags & NodeFlags.Ambient)) {
-
-                return false;
-            }
-
-            return grammarErrorOnFirstToken(node, Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
-        }
-
-        function checkShorthandPropertyAssignment(node: ShorthandPropertyAssignment): boolean {
-            return checkForInvalidQuestionMark(node, node.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional);
-        }
-
-        function checkSwitchStatement(node: SwitchStatement) {
-            var firstDefaultClause: CaseOrDefaultClause;
-
-            // Error on duplicate 'default' clauses.
-            for (var i = 0, n = node.clauses.length; i < n; i++) {
-                var clause = node.clauses[i];
-                if (clause.kind === SyntaxKind.DefaultClause) {
-                    if (firstDefaultClause === undefined) {
-                        firstDefaultClause = clause;
-                    }
-                    else {
-                        var start = skipTrivia(file.text, clause.pos);
-                        var end = clause.statements.length > 0 ? clause.statements[0].pos : clause.end;
-                        return grammarErrorAtPos(start, end - start, Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
-                    }
-                }
-            }
-        }
-
-        function checkTaggedTemplateExpression(node: TaggedTemplateExpression) {
-            if (languageVersion < ScriptTarget.ES6) {
-                return grammarErrorOnFirstToken(node.template, Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher);
-            }
-        }
-
-        function checkThrowStatement(node: ThrowStatement) {
-            if (node.expression === undefined) {
-                return grammarErrorAfterFirstToken(node, Diagnostics.Line_break_not_permitted_here);
-            }
-        }
-
-        function checkTupleType(node: TupleTypeNode) {
-            return checkForDisallowedTrailingComma(node.elementTypes) ||
-                checkForAtLeastOneType(node);
-        }
-
-        function checkForAtLeastOneType(node: TupleTypeNode): boolean {
-            if (node.elementTypes.length === 0) {
-                return grammarErrorOnNode(node, Diagnostics.A_tuple_type_element_list_cannot_be_empty)
-            }
-        }
-
-        function checkTypeParameter(node: TypeParameterDeclaration) {
-            if (node.expression) {
-                return grammarErrorOnFirstToken(node.expression, Diagnostics.Type_expected);
-            }
-        }
-
-        function checkTypeReference(node: TypeReferenceNode) {
-            return checkTypeArguments(node.typeArguments);
-        }
-
-        function checkBindingElement(node: BindingElement) {
-            if (node.parserContextFlags & ParserContextFlags.StrictMode && isEvalOrArgumentsIdentifier(node.name)) {
-                // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code 
-                // and its Identifier is eval or arguments 
-                return reportInvalidUseInStrictMode(<Identifier>node.name);
-            }
-        }
-
-        function checkVariableDeclaration(node: VariableDeclaration) {
-            if (inAmbientContext) {
-                if (isBindingPattern(node.name)) {
-                    return grammarErrorOnNode(node, Diagnostics.Destructuring_declarations_are_not_allowed_in_ambient_contexts);
-                }
-                if (node.initializer) {
-                    // Error on equals token which immediate precedes the initializer
-                    return grammarErrorAtPos(node.initializer.pos - 1, 1, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
-                }
-            }
-            else {
-                if (!node.initializer) {
-                    if (isBindingPattern(node.name) && !isBindingPattern(node.parent)) {
-                        return grammarErrorOnNode(node, Diagnostics.A_destructuring_declaration_must_have_an_initializer);
-                    }
-                    if (isConst(node)) {
-                        return grammarErrorOnNode(node, Diagnostics.const_declarations_must_be_initialized);
-                    }
-                }
-            }
-            if (node.parserContextFlags & ParserContextFlags.StrictMode && isEvalOrArgumentsIdentifier(node.name)) {
-                // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code 
-                // and its Identifier is eval or arguments 
-                return reportInvalidUseInStrictMode(<Identifier>node.name);
-            }
-        }
-
-        function checkVariableDeclarations(declarations: NodeArray<VariableDeclaration>): boolean {
-            if (declarations) {
-                if (checkForDisallowedTrailingComma(declarations)) {
-                    return true;
-                }
-
-                if (!declarations.length) {
-                    return grammarErrorAtPos(declarations.pos, declarations.end - declarations.pos, Diagnostics.Variable_declaration_list_cannot_be_empty);
-                }
-
-                var decl = declarations[0];
-                if (languageVersion < ScriptTarget.ES6) {
-                    if (isLet(decl)) {
-                        return grammarErrorOnFirstToken(decl, Diagnostics.let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
-                    }
-                    else if (isConst(decl)) {
-                        return grammarErrorOnFirstToken(decl, Diagnostics.const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
-                    }
-                }
-            }
-        }
-
-        function checkVariableStatement(node: VariableStatement) {
-            return checkVariableDeclarations(node.declarations) ||
-                checkForDisallowedLetOrConstStatement(node);
-        }
-
-        function checkForDisallowedLetOrConstStatement(node: VariableStatement) {
-            if (!allowLetAndConstDeclarations(node.parent)) {
-                if (isLet(node)) {
-                    return grammarErrorOnNode(node, Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
-                }
-                else if (isConst(node)) {
-                    return grammarErrorOnNode(node, Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
-                }
-            }
-        }
-
-        function allowLetAndConstDeclarations(parent: Node): boolean {
-            switch (parent.kind) {
-                case SyntaxKind.IfStatement:
-                case SyntaxKind.DoStatement:
-                case SyntaxKind.WhileStatement:
-                case SyntaxKind.WithStatement:
-                case SyntaxKind.ForStatement:
-                case SyntaxKind.ForInStatement:
-                    return false;
-                case SyntaxKind.LabeledStatement:
-                    return allowLetAndConstDeclarations(parent.parent);
-            }
-
-            return true;
-        }
-
-        function checkWithStatement(node: WithStatement): boolean {
-            if (node.parserContextFlags & ParserContextFlags.StrictMode) {
-                // Strict mode code may not include a WithStatement. The occurrence of a WithStatement in such 
-                // a context is an 
-                return grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
-            }
-        }
-
-        function checkYieldExpression(node: YieldExpression): boolean {
-            if (!(node.parserContextFlags & ParserContextFlags.Yield)) {
-                return grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration);
-            }
-            return grammarErrorOnFirstToken(node, Diagnostics.yield_expressions_are_not_currently_supported);
-        }
-    }
-
     export function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program {
         var program: Program;
         var files: SourceFile[] = [];
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 66a2ff25eee..f7e94beac6f 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1222,6 +1222,7 @@ module ts {
         isVisible?: boolean;              // Is this node visible
         localModuleName?: string;         // Local name for module instance
         assignmentChecks?: Map<boolean>;  // Cache of assignment checks
+        hasReportedStatementInAmbientContext?: boolean;  // Cache boolean if we report statements in ambient context
         importOnRightSide?: Symbol;       // for import declarations - import that appear on the right side
     }
 
diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
index 71aff1e2488..f129d3fa30b 100644
--- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
@@ -1,13 +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(3,20): error TS2304: Cannot find name 'yield'.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ====
     function*bar() {
             ~
 !!! error TS9001: Generators are not currently supported.
       // 'yield' here is an identifier, and not a yield expression.
       function*foo(a = yield) {
+              ~
+!!! error TS9001: Generators are not currently supported.
                        ~~~~~
 !!! 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 8de32cf0a00..8333eceb267 100644
--- a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
@@ -1,9 +1,12 @@
 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,13): error TS9002: Computed property names are not currently supported.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (1 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (2 errors) ====
     function * foo() {
              ~
 !!! error TS9001: Generators are not currently supported.
       var v = { [yield]: foo }
+                ~~~~~~~
+!!! error TS9002: Computed property names are not currently supported.
     }
\ 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 393ede66a60..eff0c79d827 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
+++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
@@ -1,7 +1,7 @@
-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,12): error TS9002: Computed property names are not currently supported.
 
 
 ==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (1 errors) ====
     var v = { *[foo()]() { } }
-              ~
-!!! error TS9001: Generators are not currently supported.
\ No newline at end of file
+               ~~~~~~~
+!!! error TS9002: Computed property names are not currently supported.
\ No newline at end of file
diff --git a/tests/baselines/reference/VariableDeclaration2_es6.errors.txt b/tests/baselines/reference/VariableDeclaration2_es6.errors.txt
index 362b68dbb35..1ae59205204 100644
--- a/tests/baselines/reference/VariableDeclaration2_es6.errors.txt
+++ b/tests/baselines/reference/VariableDeclaration2_es6.errors.txt
@@ -1,7 +1,10 @@
 tests/cases/conformance/es6/variableDeclarations/VariableDeclaration2_es6.ts(1,7): error TS1154: 'const' declarations are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/variableDeclarations/VariableDeclaration2_es6.ts(1,7): error TS1155: 'const' declarations must be initialized
 
 
-==== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration2_es6.ts (1 errors) ====
+==== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration2_es6.ts (2 errors) ====
     const a
           ~
-!!! error TS1154: 'const' declarations are only available when targeting ECMAScript 6 and higher.
\ No newline at end of file
+!!! error TS1154: 'const' declarations are only available when targeting ECMAScript 6 and higher.
+          ~
+!!! error TS1155: 'const' declarations must be initialized
\ No newline at end of file
diff --git a/tests/baselines/reference/VariableDeclaration4_es6.errors.txt b/tests/baselines/reference/VariableDeclaration4_es6.errors.txt
index ae035825312..8bb7692fb5f 100644
--- a/tests/baselines/reference/VariableDeclaration4_es6.errors.txt
+++ b/tests/baselines/reference/VariableDeclaration4_es6.errors.txt
@@ -1,7 +1,10 @@
 tests/cases/conformance/es6/variableDeclarations/VariableDeclaration4_es6.ts(1,7): error TS1154: 'const' declarations are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/variableDeclarations/VariableDeclaration4_es6.ts(1,7): error TS1155: 'const' declarations must be initialized
 
 
-==== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration4_es6.ts (1 errors) ====
+==== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration4_es6.ts (2 errors) ====
     const a: number
           ~
-!!! error TS1154: 'const' declarations are only available when targeting ECMAScript 6 and higher.
\ No newline at end of file
+!!! error TS1154: 'const' declarations are only available when targeting ECMAScript 6 and higher.
+          ~
+!!! error TS1155: 'const' declarations must be initialized
\ 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 41d6bb5bf24..e0d7ea4ad27 100644
--- a/tests/baselines/reference/YieldExpression10_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression10_es6.errors.txt
@@ -1,11 +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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (2 errors) ====
     var v = { * foo() {
               ~
 !!! error TS9001: Generators are not currently supported.
         yield(foo);
+        ~~~~~
+!!! error TS9000: 'yield' expressions are not currently supported.
       }
     }
     
\ 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 eea108619bc..3f322a81f2f 100644
--- a/tests/baselines/reference/YieldExpression11_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression11_es6.errors.txt
@@ -1,11 +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 (1 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (2 errors) ====
     class C {
       *foo() {
       ~
 !!! error TS9001: Generators are not currently supported.
         yield(foo);
+        ~~~~~
+!!! error TS9000: 'yield' expressions are not currently supported.
       }
     }
\ 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 185fb2f6193..fc2d885d381 100644
--- a/tests/baselines/reference/YieldExpression13_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression13_es6.errors.txt
@@ -1,7 +1,10 @@
 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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts (2 errors) ====
     function* foo() { yield }
             ~
-!!! error TS9001: Generators are not currently supported.
\ No newline at end of file
+!!! error TS9001: Generators are not currently supported.
+                      ~~~~~
+!!! error TS9000: 'yield' expressions are not currently supported.
\ 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 54536a7d4fe..c0d2e4c8fc8 100644
--- a/tests/baselines/reference/YieldExpression16_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression16_es6.errors.txt
@@ -1,11 +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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ====
     function* foo() {
             ~
 !!! error TS9001: Generators are not currently supported.
       function bar() {
         yield foo;
+        ~~~~~
+!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
       }
     }
\ 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 38969a9c6fb..b39f47b07f9 100644
--- a/tests/baselines/reference/YieldExpression17_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression17_es6.errors.txt
@@ -1,10 +1,13 @@
 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 (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts (3 errors) ====
     var v = { get foo() { yield foo; } }
                   ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                   ~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
\ No newline at end of file
+!!! 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
diff --git a/tests/baselines/reference/YieldExpression19_es6.errors.txt b/tests/baselines/reference/YieldExpression19_es6.errors.txt
index 81cf0e2063c..9d04d9559b0 100644
--- a/tests/baselines/reference/YieldExpression19_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression19_es6.errors.txt
@@ -1,13 +1,19 @@
 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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts (3 errors) ====
     function*foo() {
             ~
 !!! error TS9001: Generators are not currently supported.
       function bar() {
         function* quux() {
+                ~
+!!! error TS9001: Generators are not currently supported.
           yield(foo);
+          ~~~~~
+!!! error TS9000: 'yield' expressions are not currently supported.
         }
       }
     }
\ 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 91da79fbb53..1e284c92786 100644
--- a/tests/baselines/reference/YieldExpression3_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression3_es6.errors.txt
@@ -1,10 +1,16 @@
 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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts (3 errors) ====
     function* foo() {
             ~
 !!! error TS9001: Generators are not currently supported.
       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 ca7ed3d354c..2d2a7ca3257 100644
--- a/tests/baselines/reference/YieldExpression4_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression4_es6.errors.txt
@@ -1,10 +1,16 @@
 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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts (3 errors) ====
     function* foo() {
             ~
 !!! error TS9001: Generators are not currently supported.
       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 d8ce78a300f..a3d9481601a 100644
--- a/tests/baselines/reference/YieldExpression6_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression6_es6.errors.txt
@@ -1,9 +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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (2 errors) ====
     function* foo() {
             ~
 !!! error TS9001: Generators are not currently supported.
       yield*foo
+      ~~~~~
+!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ 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 87b15ac9f71..393a03ee269 100644
--- a/tests/baselines/reference/YieldExpression7_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression7_es6.errors.txt
@@ -1,9 +1,12 @@
 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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts (2 errors) ====
     function* foo() {
             ~
 !!! error TS9001: Generators are not currently supported.
       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 e8a4968fe1b..3f7933c5bb2 100644
--- a/tests/baselines/reference/YieldExpression8_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression8_es6.errors.txt
@@ -1,8 +1,9 @@
 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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (3 errors) ====
     yield(foo);
     ~~~~~
 !!! error TS2304: Cannot find name 'yield'.
@@ -10,4 +11,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error
             ~
 !!! error TS9001: Generators are not currently supported.
       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 ae1b105903a..cd753647327 100644
--- a/tests/baselines/reference/YieldExpression9_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression9_es6.errors.txt
@@ -1,9 +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 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (2 errors) ====
     var v = function*() {
                     ~
 !!! error TS9001: Generators are not currently supported.
       yield(foo);
+      ~~~~~
+!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.js b/tests/baselines/reference/accessorParameterAccessibilityModifier.js
new file mode 100644
index 00000000000..89a511e6c5c
--- /dev/null
+++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.js
@@ -0,0 +1,25 @@
+//// [accessorParameterAccessibilityModifier.ts]
+
+class C {
+    set X(public v) { }
+    static set X(public v2) { }
+}
+
+//// [accessorParameterAccessibilityModifier.js]
+var C = (function () {
+    function C() {
+    }
+    Object.defineProperty(C.prototype, "X", {
+        set: function (v) {
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(C, "X", {
+        set: function (v2) {
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return C;
+})();
diff --git a/tests/baselines/reference/ambientErrors.errors.txt b/tests/baselines/reference/ambientErrors.errors.txt
index c01b3316d44..c8159708dd8 100644
--- a/tests/baselines/reference/ambientErrors.errors.txt
+++ b/tests/baselines/reference/ambientErrors.errors.txt
@@ -1,16 +1,16 @@
 tests/cases/conformance/ambient/ambientErrors.ts(2,15): error TS1039: Initializers are not allowed in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(6,1): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
 tests/cases/conformance/ambient/ambientErrors.ts(17,22): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
-tests/cases/conformance/ambient/ambientErrors.ts(20,24): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/conformance/ambient/ambientErrors.ts(20,24): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(24,5): error TS1066: Ambient enum elements can only have integer literal initializers.
 tests/cases/conformance/ambient/ambientErrors.ts(29,5): error TS1066: Ambient enum elements can only have integer literal initializers.
 tests/cases/conformance/ambient/ambientErrors.ts(34,11): error TS1039: Initializers are not allowed in ambient contexts.
-tests/cases/conformance/ambient/ambientErrors.ts(35,19): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/conformance/ambient/ambientErrors.ts(35,19): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(37,20): error TS1039: Initializers are not allowed in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(38,13): error TS1039: Initializers are not allowed in ambient contexts.
-tests/cases/conformance/ambient/ambientErrors.ts(39,23): error TS1111: A constructor implementation cannot be declared in an ambient context.
-tests/cases/conformance/ambient/ambientErrors.ts(40,14): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/conformance/ambient/ambientErrors.ts(41,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/conformance/ambient/ambientErrors.ts(39,23): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/conformance/ambient/ambientErrors.ts(40,14): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/conformance/ambient/ambientErrors.ts(41,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(47,20): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/conformance/ambient/ambientErrors.ts(51,16): error TS2436: Ambient external module declaration cannot specify relative module name.
 tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export assignment cannot be used in a module with other exported elements.
@@ -44,7 +44,7 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export
     // Ambient function with function body
     declare function fn4() { };
                            ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     
     // Ambient enum with non - integer literal constant member
     declare enum E1 {
@@ -67,7 +67,7 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export
 !!! error TS1039: Initializers are not allowed in ambient contexts.
         function fn() { }
                       ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         class C {
             static x = 3;
                        ~
@@ -77,13 +77,13 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export
 !!! error TS1039: Initializers are not allowed in ambient contexts.
             constructor() { }
                           ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             fn() { }
                  ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static sfn() { }
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         }
     }
     
diff --git a/tests/baselines/reference/ambientWithStatements.errors.txt b/tests/baselines/reference/ambientWithStatements.errors.txt
index 2b592feb775..023dd65f56d 100644
--- a/tests/baselines/reference/ambientWithStatements.errors.txt
+++ b/tests/baselines/reference/ambientWithStatements.errors.txt
@@ -1,74 +1,44 @@
 tests/cases/compiler/ambientWithStatements.ts(2,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(3,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(4,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(5,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(7,5): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/compiler/ambientWithStatements.ts(3,5): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
 tests/cases/compiler/ambientWithStatements.ts(7,15): error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.
-tests/cases/compiler/ambientWithStatements.ts(8,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(9,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(10,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(11,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(12,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(18,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(19,5): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/ambientWithStatements.ts(25,5): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/compiler/ambientWithStatements.ts(11,5): error TS1108: A 'return' statement can only be used within a function body.
 tests/cases/compiler/ambientWithStatements.ts(25,11): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
-==== tests/cases/compiler/ambientWithStatements.ts (15 errors) ====
+==== tests/cases/compiler/ambientWithStatements.ts (5 errors) ====
     declare module M {
         break;
         ~~~~~
 !!! error TS1036: Statements are not allowed in ambient contexts.
         continue;
-        ~~~~~~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+        ~~~~~~~~~
+!!! error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
         debugger;
-        ~~~~~~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         do { } while (true);
-        ~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         var x;
         for (x in null) { }
-        ~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
                   ~~~~
 !!! error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.
         if (true) { } else { }
-        ~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         1;
-        ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         L: var y;
-        ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         return;
         ~~~~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+!!! error TS1108: A 'return' statement can only be used within a function body.
         switch (x) {
-        ~~~~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
             case 1:
                 break;
             default:
                 break;
         }
         throw "nooo";
-        ~~~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         try {
-        ~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
         }
         catch (e) {
         }
         finally {
         }
         with (x) {
-        ~~~~
-!!! error TS1036: Statements are not allowed in ambient contexts.
               ~
 !!! error TS2410: All symbols within a 'with' block will be resolved to 'any'.
         }
diff --git a/tests/baselines/reference/badArraySyntax.errors.txt b/tests/baselines/reference/badArraySyntax.errors.txt
index b22097253fc..3c6b28408f2 100644
--- a/tests/baselines/reference/badArraySyntax.errors.txt
+++ b/tests/baselines/reference/badArraySyntax.errors.txt
@@ -2,10 +2,11 @@ tests/cases/compiler/badArraySyntax.ts(6,15): error TS1150: 'new T[]' cannot be
 tests/cases/compiler/badArraySyntax.ts(7,15): error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
 tests/cases/compiler/badArraySyntax.ts(8,20): error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
 tests/cases/compiler/badArraySyntax.ts(9,20): error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
+tests/cases/compiler/badArraySyntax.ts(10,36): error TS1109: Expression expected.
 tests/cases/compiler/badArraySyntax.ts(10,40): error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
 
 
-==== tests/cases/compiler/badArraySyntax.ts (5 errors) ====
+==== tests/cases/compiler/badArraySyntax.ts (6 errors) ====
     class Z {
      public x = "";
     }
@@ -24,6 +25,8 @@ tests/cases/compiler/badArraySyntax.ts(10,40): error TS1150: 'new T[]' cannot be
                        ~~
 !!! error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
     var a6: Z[][] = new   Z     [      ]   [  ];
+                                       ~
+!!! error TS1109: Expression expected.
                                            ~~~~
 !!! error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt
index 930f2d8d813..20ec5b0c25b 100644
--- a/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt
+++ b/tests/baselines/reference/constDeclarations-invalidContexts.errors.txt
@@ -3,14 +3,13 @@ tests/cases/compiler/constDeclarations-invalidContexts.ts(6,5): error TS1156: 'c
 tests/cases/compiler/constDeclarations-invalidContexts.ts(9,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(12,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(16,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/constDeclarations-invalidContexts.ts(17,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(20,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(23,5): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(26,12): error TS1156: 'const' declarations can only be declared inside a block.
 tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156: 'const' declarations can only be declared inside a block.
 
 
-==== tests/cases/compiler/constDeclarations-invalidContexts.ts (10 errors) ====
+==== tests/cases/compiler/constDeclarations-invalidContexts.ts (9 errors) ====
     
     // Errors, const must be defined inside a block
     if (true) 
@@ -37,9 +36,7 @@ tests/cases/compiler/constDeclarations-invalidContexts.ts(29,29): error TS1156:
     with (obj) 
           ~~~
 !!! error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-        const c5 = 0;
-        ~~~~~~~~~~~~~
-!!! error TS1156: 'const' declarations can only be declared inside a block.
+        const c5 = 0;  // No  Error will be reported here since we turn off all type checking
     
     for (var i = 0; i < 10; i++)
         const c6 = 0;
diff --git a/tests/baselines/reference/constructorOverloads6.errors.txt b/tests/baselines/reference/constructorOverloads6.errors.txt
index d5cf2486fe1..65827007a8e 100644
--- a/tests/baselines/reference/constructorOverloads6.errors.txt
+++ b/tests/baselines/reference/constructorOverloads6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/constructorOverloads6.ts(4,25): error TS1111: A constructor implementation cannot be declared in an ambient context.
+tests/cases/compiler/constructorOverloads6.ts(4,25): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
 ==== tests/cases/compiler/constructorOverloads6.ts (1 errors) ====
@@ -7,7 +7,7 @@ tests/cases/compiler/constructorOverloads6.ts(4,25): error TS1111: A constructor
         constructor(n: number);
         constructor(x: any) {
                             ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     
         }
     	bar1():void;
diff --git a/tests/baselines/reference/exportAlreadySeen.errors.txt b/tests/baselines/reference/exportAlreadySeen.errors.txt
index 707b34c8d25..eb9f0ce1a95 100644
--- a/tests/baselines/reference/exportAlreadySeen.errors.txt
+++ b/tests/baselines/reference/exportAlreadySeen.errors.txt
@@ -1,12 +1,16 @@
 tests/cases/compiler/exportAlreadySeen.ts(2,12): error TS1030: 'export' modifier already seen.
 tests/cases/compiler/exportAlreadySeen.ts(3,12): error TS1030: 'export' modifier already seen.
 tests/cases/compiler/exportAlreadySeen.ts(5,12): error TS1030: 'export' modifier already seen.
+tests/cases/compiler/exportAlreadySeen.ts(6,16): error TS1030: 'export' modifier already seen.
+tests/cases/compiler/exportAlreadySeen.ts(7,16): error TS1030: 'export' modifier already seen.
 tests/cases/compiler/exportAlreadySeen.ts(12,12): error TS1030: 'export' modifier already seen.
 tests/cases/compiler/exportAlreadySeen.ts(13,12): error TS1030: 'export' modifier already seen.
 tests/cases/compiler/exportAlreadySeen.ts(15,12): error TS1030: 'export' modifier already seen.
+tests/cases/compiler/exportAlreadySeen.ts(16,16): error TS1030: 'export' modifier already seen.
+tests/cases/compiler/exportAlreadySeen.ts(17,16): error TS1030: 'export' modifier already seen.
 
 
-==== tests/cases/compiler/exportAlreadySeen.ts (6 errors) ====
+==== tests/cases/compiler/exportAlreadySeen.ts (10 errors) ====
     module M {
         export export var x = 1;
                ~~~~~~
@@ -19,7 +23,11 @@ tests/cases/compiler/exportAlreadySeen.ts(15,12): error TS1030: 'export' modifie
                ~~~~~~
 !!! error TS1030: 'export' modifier already seen.
             export export class C { }
+                   ~~~~~~
+!!! error TS1030: 'export' modifier already seen.
             export export interface I { }
+                   ~~~~~~
+!!! error TS1030: 'export' modifier already seen.
         }  
     }
     
@@ -35,6 +43,10 @@ tests/cases/compiler/exportAlreadySeen.ts(15,12): error TS1030: 'export' modifie
                ~~~~~~
 !!! error TS1030: 'export' modifier already seen.
             export export class C { }
+                   ~~~~~~
+!!! error TS1030: 'export' modifier already seen.
             export export interface I { }
+                   ~~~~~~
+!!! error TS1030: 'export' modifier already seen.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/externSyntax.errors.txt b/tests/baselines/reference/externSyntax.errors.txt
index 099c9fa3a99..1d3380b99d5 100644
--- a/tests/baselines/reference/externSyntax.errors.txt
+++ b/tests/baselines/reference/externSyntax.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/externSyntax.ts(8,20): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/externSyntax.ts(8,20): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
 ==== tests/cases/compiler/externSyntax.ts (1 errors) ====
@@ -11,7 +11,7 @@ tests/cases/compiler/externSyntax.ts(8,20): error TS1037: A function implementat
             public f();
             public g() { } // error body
                        ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         }
     }
     
diff --git a/tests/baselines/reference/giant.errors.txt b/tests/baselines/reference/giant.errors.txt
index 6d34060d2ae..fbe05bbfc79 100644
--- a/tests/baselines/reference/giant.errors.txt
+++ b/tests/baselines/reference/giant.errors.txt
@@ -42,7 +42,7 @@ tests/cases/compiler/giant.ts(125,9): error TS1169: Computed property names are
 tests/cases/compiler/giant.ts(126,9): error TS1021: An index signature must have a type annotation.
 tests/cases/compiler/giant.ts(127,10): error TS1096: An index signature must have exactly one parameter.
 tests/cases/compiler/giant.ts(140,9): error TS2386: Overload signatures must all be optional or required.
-tests/cases/compiler/giant.ts(154,39): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(154,39): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(166,16): error TS2300: Duplicate identifier 'pgF'.
 tests/cases/compiler/giant.ts(167,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(167,20): error TS2300: Duplicate identifier 'pgF'.
@@ -65,40 +65,39 @@ tests/cases/compiler/giant.ts(204,9): error TS1169: Computed property names are
 tests/cases/compiler/giant.ts(205,9): error TS1021: An index signature must have a type annotation.
 tests/cases/compiler/giant.ts(206,10): error TS1096: An index signature must have exactly one parameter.
 tests/cases/compiler/giant.ts(219,9): error TS2386: Overload signatures must all be optional or required.
-tests/cases/compiler/giant.ts(233,39): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(238,35): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(240,24): error TS1111: A constructor implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(243,21): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(244,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(233,39): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(238,35): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(240,24): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(243,21): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(244,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(245,16): error TS2300: Duplicate identifier 'pgF'.
-tests/cases/compiler/giant.ts(245,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(245,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(246,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(246,20): error TS2300: Duplicate identifier 'pgF'.
 tests/cases/compiler/giant.ts(247,16): error TS2300: Duplicate identifier 'psF'.
-tests/cases/compiler/giant.ts(247,31): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(247,31): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(248,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(248,20): error TS2300: Duplicate identifier 'psF'.
 tests/cases/compiler/giant.ts(249,17): error TS2300: Duplicate identifier 'rgF'.
-tests/cases/compiler/giant.ts(249,23): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(249,23): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(250,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(250,21): error TS2300: Duplicate identifier 'rgF'.
 tests/cases/compiler/giant.ts(251,17): error TS2300: Duplicate identifier 'rsF'.
-tests/cases/compiler/giant.ts(251,32): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(251,32): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(252,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(252,21): error TS2300: Duplicate identifier 'rsF'.
-tests/cases/compiler/giant.ts(254,21): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(254,21): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(255,16): error TS2300: Duplicate identifier 'tsF'.
-tests/cases/compiler/giant.ts(255,31): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(255,31): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(256,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(256,20): error TS2300: Duplicate identifier 'tsF'.
 tests/cases/compiler/giant.ts(257,16): error TS2300: Duplicate identifier 'tgF'.
-tests/cases/compiler/giant.ts(257,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(257,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(258,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(258,20): error TS2300: Duplicate identifier 'tgF'.
-tests/cases/compiler/giant.ts(262,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(262,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(262,25): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(267,30): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(267,33): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/compiler/giant.ts(267,30): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(281,12): error TS2300: Duplicate identifier 'pgF'.
 tests/cases/compiler/giant.ts(282,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(282,16): error TS2300: Duplicate identifier 'pgF'.
@@ -143,7 +142,7 @@ tests/cases/compiler/giant.ts(383,9): error TS1169: Computed property names are
 tests/cases/compiler/giant.ts(384,9): error TS1021: An index signature must have a type annotation.
 tests/cases/compiler/giant.ts(385,10): error TS1096: An index signature must have exactly one parameter.
 tests/cases/compiler/giant.ts(398,9): error TS2386: Overload signatures must all be optional or required.
-tests/cases/compiler/giant.ts(412,39): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(412,39): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(424,16): error TS2300: Duplicate identifier 'pgF'.
 tests/cases/compiler/giant.ts(425,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(425,20): error TS2300: Duplicate identifier 'pgF'.
@@ -166,103 +165,99 @@ tests/cases/compiler/giant.ts(462,9): error TS1169: Computed property names are
 tests/cases/compiler/giant.ts(463,9): error TS1021: An index signature must have a type annotation.
 tests/cases/compiler/giant.ts(464,10): error TS1096: An index signature must have exactly one parameter.
 tests/cases/compiler/giant.ts(477,9): error TS2386: Overload signatures must all be optional or required.
-tests/cases/compiler/giant.ts(491,39): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(496,35): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(498,24): error TS1111: A constructor implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(501,21): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(502,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(491,39): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(496,35): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(498,24): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(501,21): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(502,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(503,16): error TS2300: Duplicate identifier 'pgF'.
-tests/cases/compiler/giant.ts(503,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(503,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(504,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(504,20): error TS2300: Duplicate identifier 'pgF'.
 tests/cases/compiler/giant.ts(505,16): error TS2300: Duplicate identifier 'psF'.
-tests/cases/compiler/giant.ts(505,31): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(505,31): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(506,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(506,20): error TS2300: Duplicate identifier 'psF'.
 tests/cases/compiler/giant.ts(507,17): error TS2300: Duplicate identifier 'rgF'.
-tests/cases/compiler/giant.ts(507,23): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(507,23): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(508,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(508,21): error TS2300: Duplicate identifier 'rgF'.
 tests/cases/compiler/giant.ts(509,17): error TS2300: Duplicate identifier 'rsF'.
-tests/cases/compiler/giant.ts(509,32): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(509,32): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(510,21): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(510,21): error TS2300: Duplicate identifier 'rsF'.
-tests/cases/compiler/giant.ts(512,21): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(512,21): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(513,16): error TS2300: Duplicate identifier 'tsF'.
-tests/cases/compiler/giant.ts(513,31): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(513,31): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(514,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(514,20): error TS2300: Duplicate identifier 'tsF'.
 tests/cases/compiler/giant.ts(515,16): error TS2300: Duplicate identifier 'tgF'.
-tests/cases/compiler/giant.ts(515,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(515,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(516,20): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(516,20): error TS2300: Duplicate identifier 'tgF'.
-tests/cases/compiler/giant.ts(520,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(520,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(520,25): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(525,30): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(525,33): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(532,31): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(534,20): error TS1111: A constructor implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(537,17): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(538,18): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(525,30): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(532,31): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(534,20): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(537,17): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(538,18): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(539,12): error TS2300: Duplicate identifier 'pgF'.
-tests/cases/compiler/giant.ts(539,18): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(539,18): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(540,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(540,16): error TS2300: Duplicate identifier 'pgF'.
 tests/cases/compiler/giant.ts(541,12): error TS2300: Duplicate identifier 'psF'.
-tests/cases/compiler/giant.ts(541,27): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(541,27): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(542,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(542,16): error TS2300: Duplicate identifier 'psF'.
 tests/cases/compiler/giant.ts(543,13): error TS2300: Duplicate identifier 'rgF'.
-tests/cases/compiler/giant.ts(543,19): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(543,19): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(544,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(544,17): error TS2300: Duplicate identifier 'rgF'.
 tests/cases/compiler/giant.ts(545,13): error TS2300: Duplicate identifier 'rsF'.
-tests/cases/compiler/giant.ts(545,28): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(545,28): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(546,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(546,17): error TS2300: Duplicate identifier 'rsF'.
-tests/cases/compiler/giant.ts(548,17): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(548,17): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(549,12): error TS2300: Duplicate identifier 'tsF'.
-tests/cases/compiler/giant.ts(549,27): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(549,27): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(550,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(550,16): error TS2300: Duplicate identifier 'tsF'.
 tests/cases/compiler/giant.ts(551,12): error TS2300: Duplicate identifier 'tgF'.
-tests/cases/compiler/giant.ts(551,18): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(551,18): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(552,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/giant.ts(552,16): error TS2300: Duplicate identifier 'tgF'.
-tests/cases/compiler/giant.ts(556,18): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(556,18): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(556,21): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(558,24): error TS1111: A constructor implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(561,21): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(563,21): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(558,24): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(561,21): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(563,21): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(587,9): error TS1169: Computed property names are not allowed in interfaces.
 tests/cases/compiler/giant.ts(588,9): error TS1021: An index signature must have a type annotation.
 tests/cases/compiler/giant.ts(589,10): error TS1096: An index signature must have exactly one parameter.
 tests/cases/compiler/giant.ts(602,9): error TS2386: Overload signatures must all be optional or required.
-tests/cases/compiler/giant.ts(606,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(606,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(606,25): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(611,30): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(611,33): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/compiler/giant.ts(611,30): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(615,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
 tests/cases/compiler/giant.ts(616,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
-tests/cases/compiler/giant.ts(616,42): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/compiler/giant.ts(616,39): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(617,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
 tests/cases/compiler/giant.ts(618,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
-tests/cases/compiler/giant.ts(621,26): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(621,29): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(623,24): error TS1111: A constructor implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(626,21): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(628,21): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(621,26): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(623,24): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(626,21): error TS1184: An implementation cannot be declared in ambient contexts.
+tests/cases/compiler/giant.ts(628,21): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(653,9): error TS1169: Computed property names are not allowed in interfaces.
 tests/cases/compiler/giant.ts(654,9): error TS1021: An index signature must have a type annotation.
 tests/cases/compiler/giant.ts(655,10): error TS1096: An index signature must have exactly one parameter.
 tests/cases/compiler/giant.ts(668,9): error TS2386: Overload signatures must all be optional or required.
-tests/cases/compiler/giant.ts(672,22): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/giant.ts(672,22): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/compiler/giant.ts(672,25): error TS1036: Statements are not allowed in ambient contexts.
-tests/cases/compiler/giant.ts(676,30): error TS1037: A function implementation cannot be declared in an ambient context.
-tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
-==== tests/cases/compiler/giant.ts (262 errors) ====
+==== tests/cases/compiler/giant.ts (257 errors) ====
     
     /*
         Prefixes
@@ -506,7 +501,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export declare var eaV;
             export declare function eaF() { };
                                           ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export declare class eaC { };
             export declare module eaM { };
         }
@@ -631,31 +626,31 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export declare var eaV;
             export declare function eaF() { };
                                           ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export declare class eaC { };
             export declare module eaM { };
         }
         export declare var eaV;
         export declare function eaF() { };
                                       ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         export declare class eaC {
             constructor () { }
                            ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public pV;
             private rV;
             public pF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             private rF() { }
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public pgF() { }
                    ~~~
 !!! error TS2300: Duplicate identifier 'pgF'.
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public get pgF()
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -665,7 +660,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                    ~~~
 !!! error TS2300: Duplicate identifier 'psF'.
                                   ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public set psF(param:any)
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -675,7 +670,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                     ~~~
 !!! error TS2300: Duplicate identifier 'rgF'.
                           ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             private get rgF()
                         ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -685,7 +680,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                     ~~~
 !!! error TS2300: Duplicate identifier 'rsF'.
                                    ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             private set rsF(param:any)
                         ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -694,12 +689,12 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             static tV;
             static tF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static tsF(param:any) { }
                    ~~~
 !!! error TS2300: Duplicate identifier 'tsF'.
                                   ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static set tsF(param:any)
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -709,7 +704,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                    ~~~
 !!! error TS2300: Duplicate identifier 'tgF'.
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static get tgF()
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -720,7 +715,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             var V;
             function F() { };
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
                             ~
 !!! error TS1036: Statements are not allowed in ambient contexts.
             class C { }
@@ -729,9 +724,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export var eV;
             export function eF() { };
                                  ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
-                                    ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export class eC { }
             export interface eI { }
             export module eM { }
@@ -966,7 +959,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export declare var eaV;
             export declare function eaF() { };
                                           ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export declare class eaC { };
             export declare module eaM { };
         }
@@ -1091,31 +1084,31 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export declare var eaV;
             export declare function eaF() { };
                                           ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export declare class eaC { };
             export declare module eaM { };
         }
         export declare var eaV;
         export declare function eaF() { };
                                       ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         export declare class eaC {
             constructor () { }
                            ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public pV;
             private rV;
             public pF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             private rF() { }
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public pgF() { }
                    ~~~
 !!! error TS2300: Duplicate identifier 'pgF'.
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public get pgF()
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1125,7 +1118,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                    ~~~
 !!! error TS2300: Duplicate identifier 'psF'.
                                   ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public set psF(param:any)
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1135,7 +1128,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                     ~~~
 !!! error TS2300: Duplicate identifier 'rgF'.
                           ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             private get rgF()
                         ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1145,7 +1138,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                     ~~~
 !!! error TS2300: Duplicate identifier 'rsF'.
                                    ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             private set rsF(param:any)
                         ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1154,12 +1147,12 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             static tV;
             static tF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static tsF(param:any) { }
                    ~~~
 !!! error TS2300: Duplicate identifier 'tsF'.
                                   ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static set tsF(param:any)
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1169,7 +1162,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                    ~~~
 !!! error TS2300: Duplicate identifier 'tgF'.
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static get tgF()
                        ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1180,7 +1173,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             var V;
             function F() { };
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
                             ~
 !!! error TS1036: Statements are not allowed in ambient contexts.
             class C { }
@@ -1189,9 +1182,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export var eV;
             export function eF() { };
                                  ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
-                                    ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export class eC { }
             export interface eI { }
             export module eM { }
@@ -1200,24 +1191,24 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
     export declare var eaV;
     export declare function eaF() { };
                                   ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     export declare class eaC {
         constructor () { }
                        ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         public pV;
         private rV;
         public pF() { }
                     ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         private rF() { }
                      ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         public pgF() { }
                ~~~
 !!! error TS2300: Duplicate identifier 'pgF'.
                      ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         public get pgF()
                    ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1227,7 +1218,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                ~~~
 !!! error TS2300: Duplicate identifier 'psF'.
                               ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         public set psF(param:any)
                    ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1237,7 +1228,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                 ~~~
 !!! error TS2300: Duplicate identifier 'rgF'.
                       ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         private get rgF()
                     ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1247,7 +1238,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                 ~~~
 !!! error TS2300: Duplicate identifier 'rsF'.
                                ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         private set rsF(param:any)
                     ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1256,12 +1247,12 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
         static tV;
         static tF() { }
                     ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         static tsF(param:any) { }
                ~~~
 !!! error TS2300: Duplicate identifier 'tsF'.
                               ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         static set tsF(param:any)
                    ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1271,7 +1262,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
                ~~~
 !!! error TS2300: Duplicate identifier 'tgF'.
                      ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         static get tgF()
                    ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -1282,22 +1273,22 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
         var V;
         function F() { };
                      ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
                         ~
 !!! error TS1036: Statements are not allowed in ambient contexts.
         class C {
             constructor () { }
                            ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public pV;
             private rV;
             public pF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static tV;
             static tF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         }
         interface I {
             //Call Signature
@@ -1350,7 +1341,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             var V;
             function F() { };
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
                             ~
 !!! error TS1036: Statements are not allowed in ambient contexts.
             class C { }
@@ -1359,9 +1350,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export var eV;
             export function eF() { };
                                  ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
-                                    ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export class eC { }
             export interface eI { }
             export module eM { }
@@ -1371,8 +1360,8 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export declare function eaF() { };
                    ~~~~~~~
 !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context.
-                                             ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+                                          ~
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export declare class eaC { }
                    ~~~~~~~
 !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context.
@@ -1383,22 +1372,20 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
         export var eV;
         export function eF() { };
                              ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
-                                ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         export class eC {
             constructor () { }
                            ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             public pV;
             private rV;
             public pF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             static tV
             static tF() { }
                         ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         }
         export interface eI {
             //Call Signature
@@ -1452,7 +1439,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             var V;
             function F() { };
                          ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
                             ~
 !!! error TS1036: Statements are not allowed in ambient contexts.
             class C { }
@@ -1460,9 +1447,7 @@ tests/cases/compiler/giant.ts(676,33): error TS1036: Statements are not allowed
             export var eV;
             export function eF() { };
                                  ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
-                                    ~
-!!! error TS1036: Statements are not allowed in ambient contexts.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
             export class eC { }
             export interface eI { }
             export module eM { }
diff --git a/tests/baselines/reference/initializersInDeclarations.errors.txt b/tests/baselines/reference/initializersInDeclarations.errors.txt
index 5ab9ae5d2bc..9840181e092 100644
--- a/tests/baselines/reference/initializersInDeclarations.errors.txt
+++ b/tests/baselines/reference/initializersInDeclarations.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/externalModules/initializersInDeclarations.ts(5,9): error TS1039: Initializers are not allowed in ambient contexts.
 tests/cases/conformance/externalModules/initializersInDeclarations.ts(6,16): error TS1039: Initializers are not allowed in ambient contexts.
-tests/cases/conformance/externalModules/initializersInDeclarations.ts(7,16): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/conformance/externalModules/initializersInDeclarations.ts(7,16): error TS1184: An implementation cannot be declared in ambient contexts.
 tests/cases/conformance/externalModules/initializersInDeclarations.ts(12,15): error TS1039: Initializers are not allowed in ambient contexts.
 tests/cases/conformance/externalModules/initializersInDeclarations.ts(13,15): error TS1039: Initializers are not allowed in ambient contexts.
 tests/cases/conformance/externalModules/initializersInDeclarations.ts(16,2): error TS1036: Statements are not allowed in ambient contexts.
@@ -20,7 +20,7 @@ tests/cases/conformance/externalModules/initializersInDeclarations.ts(18,16): er
 !!! error TS1039: Initializers are not allowed in ambient contexts.
     	fn(): boolean {
     	              ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     		return false;
     	}
     }
diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
index f8115718b80..1ece1f31433 100644
--- a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
+++ b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
@@ -3,14 +3,13 @@ tests/cases/compiler/letDeclarations-invalidContexts.ts(6,5): error TS1157: 'let
 tests/cases/compiler/letDeclarations-invalidContexts.ts(9,5): error TS1157: 'let' declarations can only be declared inside a block.
 tests/cases/compiler/letDeclarations-invalidContexts.ts(12,5): error TS1157: 'let' declarations can only be declared inside a block.
 tests/cases/compiler/letDeclarations-invalidContexts.ts(16,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(17,5): error TS1157: 'let' declarations can only be declared inside a block.
 tests/cases/compiler/letDeclarations-invalidContexts.ts(20,5): error TS1157: 'let' declarations can only be declared inside a block.
 tests/cases/compiler/letDeclarations-invalidContexts.ts(23,5): error TS1157: 'let' declarations can only be declared inside a block.
 tests/cases/compiler/letDeclarations-invalidContexts.ts(26,12): error TS1157: 'let' declarations can only be declared inside a block.
 tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'let' declarations can only be declared inside a block.
 
 
-==== tests/cases/compiler/letDeclarations-invalidContexts.ts (10 errors) ====
+==== tests/cases/compiler/letDeclarations-invalidContexts.ts (9 errors) ====
     
     // Errors, let must be defined inside a block
     if (true) 
@@ -38,8 +37,6 @@ tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'l
           ~~~
 !!! error TS2410: All symbols within a 'with' block will be resolved to 'any'.
         let l5 = 0;
-        ~~~~~~~~~~~
-!!! error TS1157: 'let' declarations can only be declared inside a block.
     
     for (var i = 0; i < 10; i++)
         let l6 = 0;
diff --git a/tests/baselines/reference/methodInAmbientClass1.errors.txt b/tests/baselines/reference/methodInAmbientClass1.errors.txt
index 2c99dfdde0a..05183378a85 100644
--- a/tests/baselines/reference/methodInAmbientClass1.errors.txt
+++ b/tests/baselines/reference/methodInAmbientClass1.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/methodInAmbientClass1.ts(2,12): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
-tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
 ==== tests/cases/compiler/methodInAmbientClass1.ts (2 errors) ====
@@ -8,6 +8,6 @@ tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1037: A function im
         	      ~~~~~~~
 !!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
         	              ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         	}
         }
\ No newline at end of file
diff --git a/tests/baselines/reference/missingRequiredDeclare.d.errors.txt b/tests/baselines/reference/missingRequiredDeclare.d.errors.txt
index 1e52fa92fe5..dc713c86d89 100644
--- a/tests/baselines/reference/missingRequiredDeclare.d.errors.txt
+++ b/tests/baselines/reference/missingRequiredDeclare.d.errors.txt
@@ -1,7 +1,10 @@
 tests/cases/compiler/missingRequiredDeclare.d.ts(1,1): error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+tests/cases/compiler/missingRequiredDeclare.d.ts(1,7): error TS1039: Initializers are not allowed in ambient contexts.
 
 
-==== tests/cases/compiler/missingRequiredDeclare.d.ts (1 errors) ====
+==== tests/cases/compiler/missingRequiredDeclare.d.ts (2 errors) ====
     var x = 1;
     ~~~
-!!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
\ No newline at end of file
+!!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+          ~
+!!! error TS1039: Initializers are not allowed in ambient contexts.
\ No newline at end of file
diff --git a/tests/baselines/reference/newOperator.errors.txt b/tests/baselines/reference/newOperator.errors.txt
index 50a25a16a2c..7998217f2e5 100644
--- a/tests/baselines/reference/newOperator.errors.txt
+++ b/tests/baselines/reference/newOperator.errors.txt
@@ -9,9 +9,10 @@ tests/cases/compiler/newOperator.ts(22,1): error TS1150: 'new T[]' cannot be use
 tests/cases/compiler/newOperator.ts(28,13): error TS2304: Cannot find name 'q'.
 tests/cases/compiler/newOperator.ts(31,10): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
 tests/cases/compiler/newOperator.ts(44,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/newOperator.ts(45,23): error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
 
 
-==== tests/cases/compiler/newOperator.ts (11 errors) ====
+==== tests/cases/compiler/newOperator.ts (12 errors) ====
     interface ifc { }
     // Attempting to 'new' an interface yields poor error
     var i = new ifc();
@@ -80,6 +81,8 @@ tests/cases/compiler/newOperator.ts(44,16): error TS1056: Accessors are only ava
                    ~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
             return new M.T[];
+                          ~~
+!!! error TS1150: 'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.
         }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/parserClassDeclaration18.errors.txt b/tests/baselines/reference/parserClassDeclaration18.errors.txt
index 990b69a1013..ce4b01d5253 100644
--- a/tests/baselines/reference/parserClassDeclaration18.errors.txt
+++ b/tests/baselines/reference/parserClassDeclaration18.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration18.ts(4,25): error TS1111: A constructor implementation cannot be declared in an ambient context.
+tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration18.ts(4,25): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration18.ts (1 errors) ====
@@ -7,7 +7,7 @@ tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclarat
         constructor(n: number);
         constructor(x: any) {
                             ~
-!!! error TS1111: A constructor implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
         }
         bar1():void;
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserConstructorDeclaration11.errors.txt b/tests/baselines/reference/parserConstructorDeclaration11.errors.txt
index 7e5c305fb80..e8a799fc36a 100644
--- a/tests/baselines/reference/parserConstructorDeclaration11.errors.txt
+++ b/tests/baselines/reference/parserConstructorDeclaration11.errors.txt
@@ -1,9 +1,12 @@
 tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration11.ts(2,14): error TS1098: Type parameter list cannot be empty.
+tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration11.ts(2,15): error TS1092: Type parameters cannot appear on a constructor declaration.
 
 
-==== tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration11.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration11.ts (2 errors) ====
     class C {
       constructor<>() { }
                  ~~
 !!! error TS1098: Type parameter list cannot be empty.
+                  
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserConstructorDeclaration12.errors.txt b/tests/baselines/reference/parserConstructorDeclaration12.errors.txt
index 181a3b2215f..8f0a872a0af 100644
--- a/tests/baselines/reference/parserConstructorDeclaration12.errors.txt
+++ b/tests/baselines/reference/parserConstructorDeclaration12.errors.txt
@@ -1,61 +1,85 @@
 tests/cases/compiler/parserConstructorDeclaration12.ts(2,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(2,14): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(2,15): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(3,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(3,14): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(3,15): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(4,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(4,15): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(4,16): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(5,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(5,15): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(5,16): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(6,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(6,14): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(6,15): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(7,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(7,14): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(7,15): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(8,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(8,15): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(8,16): error TS1092: Type parameters cannot appear on a constructor declaration.
 tests/cases/compiler/parserConstructorDeclaration12.ts(9,3): error TS2392: Multiple constructor implementations are not allowed.
 tests/cases/compiler/parserConstructorDeclaration12.ts(9,15): error TS1098: Type parameter list cannot be empty.
+tests/cases/compiler/parserConstructorDeclaration12.ts(9,16): error TS1092: Type parameters cannot appear on a constructor declaration.
 
 
-==== tests/cases/compiler/parserConstructorDeclaration12.ts (16 errors) ====
+==== tests/cases/compiler/parserConstructorDeclaration12.ts (24 errors) ====
     class C {
       constructor<>() { }
       ~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                  ~~
 !!! error TS1098: Type parameter list cannot be empty.
+                  
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor<> () { }
       ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                  ~~
 !!! error TS1098: Type parameter list cannot be empty.
+                  
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor <>() { }
       ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                   ~~
 !!! error TS1098: Type parameter list cannot be empty.
+                   
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor <> () { }
       ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                   ~~
 !!! error TS1098: Type parameter list cannot be empty.
+                   
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor< >() { }
       ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                  ~~~
 !!! error TS1098: Type parameter list cannot be empty.
+                  
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor< > () { }
       ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                  ~~~
 !!! error TS1098: Type parameter list cannot be empty.
+                  
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor < >() { }
       ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                   ~~~
 !!! error TS1098: Type parameter list cannot be empty.
+                   
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
       constructor < > () { }
       ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2392: Multiple constructor implementations are not allowed.
                   ~~~
 !!! error TS1098: Type parameter list cannot be empty.
+                   
+!!! error TS1092: Type parameters cannot appear on a constructor declaration.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserConstructorDeclaration4.errors.txt b/tests/baselines/reference/parserConstructorDeclaration4.errors.txt
index bd27ccbb255..e851885f0ee 100644
--- a/tests/baselines/reference/parserConstructorDeclaration4.errors.txt
+++ b/tests/baselines/reference/parserConstructorDeclaration4.errors.txt
@@ -1,9 +1,12 @@
 tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts(2,3): error TS1031: 'declare' modifier cannot appear on a class element.
+tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts(2,25): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
-==== tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts (2 errors) ====
     class C {
       declare constructor() { }
       ~~~~~~~
 !!! error TS1031: 'declare' modifier cannot appear on a class element.
+                            ~
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt b/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt
index f623642e827..9aee5f2b0e7 100644
--- a/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt
+++ b/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt
@@ -1,8 +1,11 @@
 tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts(1,1): error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts(1,14): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
-==== tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts (2 errors) ====
     function F() {
     ~~~~~~~~
 !!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+                 ~
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserFunctionDeclaration2.errors.txt b/tests/baselines/reference/parserFunctionDeclaration2.errors.txt
index 0b09c7c6956..deb96553220 100644
--- a/tests/baselines/reference/parserFunctionDeclaration2.errors.txt
+++ b/tests/baselines/reference/parserFunctionDeclaration2.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts(1,24): error TS1037: A function implementation cannot be declared in an ambient context.
+tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts(1,24): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts (1 errors) ====
     declare function Foo() {
                            ~
-!!! error TS1037: A function implementation cannot be declared in an ambient context.
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration15.js b/tests/baselines/reference/parserMemberAccessorDeclaration15.js
new file mode 100644
index 00000000000..59ff360d432
--- /dev/null
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration15.js
@@ -0,0 +1,17 @@
+//// [parserMemberAccessorDeclaration15.ts]
+class C {
+   set Foo(public a: number) { }
+}
+
+//// [parserMemberAccessorDeclaration15.js]
+var C = (function () {
+    function C() {
+    }
+    Object.defineProperty(C.prototype, "Foo", {
+        set: function (a) {
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return C;
+})();
diff --git a/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt b/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt
index dc19cb0f855..12fb40ad232 100644
--- a/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt
+++ b/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt
@@ -1,9 +1,12 @@
 tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts(2,5): error TS1031: 'declare' modifier cannot appear on a class element.
+tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts(2,19): error TS1184: An implementation cannot be declared in ambient contexts.
 
 
-==== tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts (2 errors) ====
     class C {
         declare Foo() { }
         ~~~~~~~
 !!! error TS1031: 'declare' modifier cannot appear on a class element.
+                      ~
+!!! error TS1184: An implementation cannot be declared in ambient contexts.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserModuleDeclaration4.d.errors.txt b/tests/baselines/reference/parserModuleDeclaration4.d.errors.txt
index 3f7cc9c53d3..2e75c6cbc50 100644
--- a/tests/baselines/reference/parserModuleDeclaration4.d.errors.txt
+++ b/tests/baselines/reference/parserModuleDeclaration4.d.errors.txt
@@ -1,10 +1,13 @@
 tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration4.d.ts(1,1): error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration4.d.ts(2,3): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
 
 
-==== tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration4.d.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration4.d.ts (2 errors) ====
     module M {
     ~~~~~~
 !!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
       declare module M1 {
+      ~~~~~~~
+!!! error TS1038: A 'declare' modifier cannot be used in an already ambient context.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserShorthandPropertyAssignment1.errors.txt b/tests/baselines/reference/parserShorthandPropertyAssignment1.errors.txt
new file mode 100644
index 00000000000..b877d853bdd
--- /dev/null
+++ b/tests/baselines/reference/parserShorthandPropertyAssignment1.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts(3,11): error TS1162: An object member cannot be declared optional.
+tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts(3,16): error TS1162: An object member cannot be declared optional.
+
+
+==== tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts (2 errors) ====
+    function foo(obj: { name?: string; id: number }) { }
+    var name:any, id: any;
+    foo({ name?, id? });
+              ~
+!!! error TS1162: An object member cannot be declared optional.
+                   ~
+!!! error TS1162: An object member cannot be declared optional.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserShorthandPropertyAssignment2.errors.txt b/tests/baselines/reference/parserShorthandPropertyAssignment2.errors.txt
new file mode 100644
index 00000000000..d6841652600
--- /dev/null
+++ b/tests/baselines/reference/parserShorthandPropertyAssignment2.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment2.ts(1,17): error TS1005: ':' expected.
+
+
+==== tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment2.ts (1 errors) ====
+    var v = { class };
+                    ~
+!!! error TS1005: ':' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserShorthandPropertyAssignment3.errors.txt b/tests/baselines/reference/parserShorthandPropertyAssignment3.errors.txt
new file mode 100644
index 00000000000..aa8fbfb2beb
--- /dev/null
+++ b/tests/baselines/reference/parserShorthandPropertyAssignment3.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment3.ts(1,14): error TS1005: ':' expected.
+
+
+==== tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment3.ts (1 errors) ====
+    var v = { "" };
+                 ~
+!!! error TS1005: ':' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserShorthandPropertyAssignment4.errors.txt b/tests/baselines/reference/parserShorthandPropertyAssignment4.errors.txt
new file mode 100644
index 00000000000..8cadf423e19
--- /dev/null
+++ b/tests/baselines/reference/parserShorthandPropertyAssignment4.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment4.ts(1,13): error TS1005: ':' expected.
+
+
+==== tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment4.ts (1 errors) ====
+    var v = { 0 };
+                ~
+!!! error TS1005: ':' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserShorthandPropertyAssignment5.errors.txt b/tests/baselines/reference/parserShorthandPropertyAssignment5.errors.txt
new file mode 100644
index 00000000000..714881727b8
--- /dev/null
+++ b/tests/baselines/reference/parserShorthandPropertyAssignment5.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment5.ts(2,18): error TS1162: An object member cannot be declared optional.
+
+
+==== tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment5.ts (1 errors) ====
+    var greet = "hello";
+    var obj = { greet? }; 
+                     ~
+!!! error TS1162: An object member cannot be declared optional.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserVariableStatement1.d.errors.txt b/tests/baselines/reference/parserVariableStatement1.d.errors.txt
index 7176e5ed69f..de0bef5288c 100644
--- a/tests/baselines/reference/parserVariableStatement1.d.errors.txt
+++ b/tests/baselines/reference/parserVariableStatement1.d.errors.txt
@@ -1,7 +1,10 @@
 tests/cases/conformance/parser/ecmascript5/Statements/parserVariableStatement1.d.ts(1,1): error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+tests/cases/conformance/parser/ecmascript5/Statements/parserVariableStatement1.d.ts(1,7): error TS1039: Initializers are not allowed in ambient contexts.
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/parserVariableStatement1.d.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/parserVariableStatement1.d.ts (2 errors) ====
     var v = 1;
     ~~~
-!!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
\ No newline at end of file
+!!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file.
+          ~
+!!! error TS1039: Initializers are not allowed in ambient contexts.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserWithStatement2.errors.txt b/tests/baselines/reference/parserWithStatement2.errors.txt
index c2d4b2efa96..bab548de06e 100644
--- a/tests/baselines/reference/parserWithStatement2.errors.txt
+++ b/tests/baselines/reference/parserWithStatement2.errors.txt
@@ -1,11 +1,8 @@
 tests/cases/conformance/parser/ecmascript5/Statements/parserWithStatement2.ts(1,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/conformance/parser/ecmascript5/Statements/parserWithStatement2.ts(2,3): error TS1108: A 'return' statement can only be used within a function body.
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/parserWithStatement2.ts (2 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/parserWithStatement2.ts (1 errors) ====
     with (1)
           ~
 !!! error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-      return;
-      ~~~~~~
-!!! error TS1108: A 'return' statement can only be used within a function body.
\ No newline at end of file
+      return;
\ No newline at end of file
diff --git a/tests/baselines/reference/parserWithStatement2.js b/tests/baselines/reference/parserWithStatement2.js
new file mode 100644
index 00000000000..be3ed9c6c24
--- /dev/null
+++ b/tests/baselines/reference/parserWithStatement2.js
@@ -0,0 +1,7 @@
+//// [parserWithStatement2.ts]
+with (1)
+  return;
+
+//// [parserWithStatement2.js]
+with (1)
+    return;
diff --git a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
index 5c632c09cd4..fa3b1bb522d 100644
--- a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
+++ b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt
@@ -2,16 +2,21 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(22,27): error TS2435: Ambien
 tests/cases/compiler/privacyGloImportParseErrors.ts(30,20): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS2307: Cannot find external module 'm1_M3_public'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(69,37): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(69,37): error TS2307: Cannot find external module 'm1_M4_private'.
+tests/cases/compiler/privacyGloImportParseErrors.ts(81,43): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyGloImportParseErrors.ts(82,43): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(121,38): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyGloImportParseErrors.ts(125,45): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyGloImportParseErrors.ts(133,9): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
 tests/cases/compiler/privacyGloImportParseErrors.ts(133,24): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(138,16): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(141,12): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Import declarations in an internal module cannot reference an external module.
 
 
-==== tests/cases/compiler/privacyGloImportParseErrors.ts (11 errors) ====
+==== tests/cases/compiler/privacyGloImportParseErrors.ts (16 errors) ====
     module m1 {
         export module m1_M1_public {
             export class c1 {
@@ -90,6 +95,8 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Impor
     
         import m1_im4_private = require("m1_M4_private");
                                         ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                        ~~~~~~~~~~~~~~~
 !!! error TS2307: Cannot find external module 'm1_M4_private'.
         export var m1_im4_private_v1_public = m1_im4_private.c1;
         export var m1_im4_private_v2_public = new m1_im4_private.c1();
@@ -103,7 +110,11 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Impor
         export import m1_im1_public = m1_M1_public;
         export import m1_im2_public = m1_M2_private;
         export import m1_im3_public = require("m1_M3_public");
+                                              ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
         export import m1_im4_public = require("m1_M4_private");
+                                              ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
     }
     
     module glo_M1_public {
@@ -149,6 +160,8 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Impor
     
             module m5 {
                 import m5_errorImport = require("glo_M2_public");
+                                                ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
                 import m5_nonerrorImport = glo_M1_public;
             }
         }
@@ -183,6 +196,8 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Impor
         module m4 {
             var a = 10;
             import m2 = require("use_glo_M1_public");
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
         }
     
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/privacyImportParseErrors.errors.txt b/tests/baselines/reference/privacyImportParseErrors.errors.txt
index 51199196ad7..a81bfbe738b 100644
--- a/tests/baselines/reference/privacyImportParseErrors.errors.txt
+++ b/tests/baselines/reference/privacyImportParseErrors.errors.txt
@@ -2,12 +2,18 @@ tests/cases/compiler/privacyImportParseErrors.ts(22,27): error TS2435: Ambient e
 tests/cases/compiler/privacyImportParseErrors.ts(30,20): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(59,37): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(59,37): error TS2307: Cannot find external module 'm1_M3_public'.
+tests/cases/compiler/privacyImportParseErrors.ts(69,37): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(69,37): error TS2307: Cannot find external module 'm1_M4_private'.
+tests/cases/compiler/privacyImportParseErrors.ts(81,43): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyImportParseErrors.ts(82,43): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(106,27): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(114,20): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(143,37): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(143,37): error TS2307: Cannot find external module 'm2_M3_public'.
+tests/cases/compiler/privacyImportParseErrors.ts(153,37): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(153,37): error TS2307: Cannot find external module 'm2_M4_private'.
+tests/cases/compiler/privacyImportParseErrors.ts(166,43): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyImportParseErrors.ts(167,43): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(180,23): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(198,23): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(218,34): error TS2307: Cannot find external module 'glo_M2_public'.
@@ -19,11 +25,13 @@ tests/cases/compiler/privacyImportParseErrors.ts(258,45): error TS2304: Cannot f
 tests/cases/compiler/privacyImportParseErrors.ts(261,39): error TS2304: Cannot find name 'use_glo_M1_public'.
 tests/cases/compiler/privacyImportParseErrors.ts(264,40): error TS2307: Cannot find external module 'glo_M2_public'.
 tests/cases/compiler/privacyImportParseErrors.ts(273,38): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyImportParseErrors.ts(277,45): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(284,16): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(287,46): error TS2304: Cannot find name 'use_glo_M3_private'.
 tests/cases/compiler/privacyImportParseErrors.ts(290,40): error TS2304: Cannot find name 'use_glo_M3_private'.
 tests/cases/compiler/privacyImportParseErrors.ts(293,41): error TS2307: Cannot find external module 'glo_M4_private'.
 tests/cases/compiler/privacyImportParseErrors.ts(302,38): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyImportParseErrors.ts(306,45): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(312,16): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(314,9): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
 tests/cases/compiler/privacyImportParseErrors.ts(314,24): error TS2435: Ambient external modules cannot be nested in other modules.
@@ -31,14 +39,17 @@ tests/cases/compiler/privacyImportParseErrors.ts(319,16): error TS2435: Ambient
 tests/cases/compiler/privacyImportParseErrors.ts(322,12): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(326,9): error TS1029: 'export' modifier must precede 'declare' modifier.
 tests/cases/compiler/privacyImportParseErrors.ts(326,23): error TS2435: Ambient external modules cannot be nested in other modules.
+tests/cases/compiler/privacyImportParseErrors.ts(328,9): error TS1038: A 'declare' modifier cannot be used in an already ambient context.
 tests/cases/compiler/privacyImportParseErrors.ts(328,24): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(333,16): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(336,12): error TS2435: Ambient external modules cannot be nested in other modules.
 tests/cases/compiler/privacyImportParseErrors.ts(341,25): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyImportParseErrors.ts(344,29): error TS1147: Import declarations in an internal module cannot reference an external module.
 tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import declarations in an internal module cannot reference an external module.
+tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import declarations in an internal module cannot reference an external module.
 
 
-==== tests/cases/compiler/privacyImportParseErrors.ts (38 errors) ====
+==== tests/cases/compiler/privacyImportParseErrors.ts (49 errors) ====
     export module m1 {
         export module m1_M1_public {
             export class c1 {
@@ -117,6 +128,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
     
         import m1_im4_private = require("m1_M4_private");
                                         ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                        ~~~~~~~~~~~~~~~
 !!! error TS2307: Cannot find external module 'm1_M4_private'.
         export var m1_im4_private_v1_public = m1_im4_private.c1;
         export var m1_im4_private_v2_public = new m1_im4_private.c1();
@@ -130,7 +143,11 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
         export import m1_im1_public = m1_M1_public;
         export import m1_im2_public = m1_M2_private;
         export import m1_im3_public = require("m1_M3_public");
+                                              ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
         export import m1_im4_public = require("m1_M4_private");
+                                              ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
     }
     
     module m2 {
@@ -211,6 +228,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
     
         import m1_im4_private = require("m2_M4_private");
                                         ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                        ~~~~~~~~~~~~~~~
 !!! error TS2307: Cannot find external module 'm2_M4_private'.
         export var m1_im4_private_v1_public = m1_im4_private.c1;
         export var m1_im4_private_v2_public = new m1_im4_private.c1();
@@ -225,7 +244,11 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
         export import m1_im1_public = m2_M1_public;
         export import m1_im2_public = m2_M2_private;
         export import m1_im3_public = require("m2_M3_public");
+                                              ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
         export import m1_im4_public = require("m2_M4_private");
+                                              ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
     }
     
     export module glo_M1_public {
@@ -358,6 +381,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
     
             module m5 {
                 import m5_errorImport = require("glo_M2_public");
+                                                ~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
                 import m5_nonerrorImport = glo_M1_public;
             }
         }
@@ -397,6 +422,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
     
             module m5 {
                 import m5_errorImport = require("glo_M4_private");
+                                                ~~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
                 import m5_nonerrorImport = glo_M3_private;
             }
         }
@@ -433,6 +460,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
 !!! error TS2435: Ambient external modules cannot be nested in other modules.
         module m2 {
             declare module "abc" {
+            ~~~~~~~
+!!! error TS1038: A 'declare' modifier cannot be used in an already ambient context.
                            ~~~~~
 !!! error TS2435: Ambient external modules cannot be nested in other modules.
             }
@@ -457,6 +486,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
         module m4 {
             var a = 10;
             import m2 = require("use_glo_M1_public");
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
         }
     
     }
@@ -468,6 +499,8 @@ tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import d
         module m4 {
             var a = 10;
             import m2 = require("use_glo_M1_public");
+                                ~~~~~~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
         }
     
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/intReferencingExtAndInt/amd/intReferencingExtAndInt.errors.txt b/tests/baselines/reference/project/intReferencingExtAndInt/amd/intReferencingExtAndInt.errors.txt
index fd808bc1443..bfc09e40188 100644
--- a/tests/baselines/reference/project/intReferencingExtAndInt/amd/intReferencingExtAndInt.errors.txt
+++ b/tests/baselines/reference/project/intReferencingExtAndInt/amd/intReferencingExtAndInt.errors.txt
@@ -1,11 +1,14 @@
 internal2.ts(2,21): error TS1147: Import declarations in an internal module cannot reference an external module.
+internal2.ts(2,21): error TS2307: Cannot find external module 'external2'.
 
 
-==== internal2.ts (1 errors) ====
+==== internal2.ts (2 errors) ====
     module outer {
     	import g = require("external2")
     	                   ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+    	                   ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'external2'.
     	export var a = g.square(5);
     	export var b = "foo";
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/intReferencingExtAndInt/node/intReferencingExtAndInt.errors.txt b/tests/baselines/reference/project/intReferencingExtAndInt/node/intReferencingExtAndInt.errors.txt
index fd808bc1443..bfc09e40188 100644
--- a/tests/baselines/reference/project/intReferencingExtAndInt/node/intReferencingExtAndInt.errors.txt
+++ b/tests/baselines/reference/project/intReferencingExtAndInt/node/intReferencingExtAndInt.errors.txt
@@ -1,11 +1,14 @@
 internal2.ts(2,21): error TS1147: Import declarations in an internal module cannot reference an external module.
+internal2.ts(2,21): error TS2307: Cannot find external module 'external2'.
 
 
-==== internal2.ts (1 errors) ====
+==== internal2.ts (2 errors) ====
     module outer {
     	import g = require("external2")
     	                   ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+    	                   ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'external2'.
     	export var a = g.square(5);
     	export var b = "foo";
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/amd/nestedLocalModuleWithRecursiveTypecheck.errors.txt b/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/amd/nestedLocalModuleWithRecursiveTypecheck.errors.txt
index 9d1540829fc..e205f308c0a 100644
--- a/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/amd/nestedLocalModuleWithRecursiveTypecheck.errors.txt
+++ b/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/amd/nestedLocalModuleWithRecursiveTypecheck.errors.txt
@@ -1,12 +1,15 @@
 test1.ts(3,23): error TS1147: Import declarations in an internal module cannot reference an external module.
+test1.ts(3,23): error TS2307: Cannot find external module 'test2'.
 
 
-==== test1.ts (1 errors) ====
+==== test1.ts (2 errors) ====
     module myModule {
      
      import foo = require("test2");
                           ~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                          ~~~~~~~
+!!! error TS2307: Cannot find external module 'test2'.
     
      //console.log(foo.$);
     
diff --git a/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/node/nestedLocalModuleWithRecursiveTypecheck.errors.txt b/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/node/nestedLocalModuleWithRecursiveTypecheck.errors.txt
index 9d1540829fc..e205f308c0a 100644
--- a/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/node/nestedLocalModuleWithRecursiveTypecheck.errors.txt
+++ b/tests/baselines/reference/project/nestedLocalModuleWithRecursiveTypecheck/node/nestedLocalModuleWithRecursiveTypecheck.errors.txt
@@ -1,12 +1,15 @@
 test1.ts(3,23): error TS1147: Import declarations in an internal module cannot reference an external module.
+test1.ts(3,23): error TS2307: Cannot find external module 'test2'.
 
 
-==== test1.ts (1 errors) ====
+==== test1.ts (2 errors) ====
     module myModule {
      
      import foo = require("test2");
                           ~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                          ~~~~~~~
+!!! error TS2307: Cannot find external module 'test2'.
     
      //console.log(foo.$);
     
diff --git a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/amd/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/amd/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt
index f15b4d3379b..eabc4e5656a 100644
--- a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/amd/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt
+++ b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/amd/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt
@@ -1,11 +1,16 @@
 testGlo.ts(2,39): error TS1147: Import declarations in an internal module cannot reference an external module.
+testGlo.ts(2,39): error TS2307: Cannot find external module 'mExported'.
+testGlo.ts(21,35): error TS1147: Import declarations in an internal module cannot reference an external module.
+testGlo.ts(21,35): error TS2307: Cannot find external module 'mNonExported'.
 
 
-==== testGlo.ts (1 errors) ====
+==== testGlo.ts (4 errors) ====
     module m2 {
         export import mExported = require("mExported");
                                           ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                          ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mExported'.
         export var c1 = new mExported.me.class1;
         export function f1() {
             return new mExported.me.class1();
@@ -25,6 +30,10 @@ testGlo.ts(2,39): error TS1147: Import declarations in an internal module cannot
         }
     
         import mNonExported = require("mNonExported");
+                                      ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mNonExported'.
         export var c3 = new mNonExported.mne.class1;
         export function f3() {
             return new mNonExported.mne.class1();
diff --git a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/node/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/node/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt
index f15b4d3379b..eabc4e5656a 100644
--- a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/node/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt
+++ b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideModule/node/privacyCheckOnImportedModuleDeclarationsInsideModule.errors.txt
@@ -1,11 +1,16 @@
 testGlo.ts(2,39): error TS1147: Import declarations in an internal module cannot reference an external module.
+testGlo.ts(2,39): error TS2307: Cannot find external module 'mExported'.
+testGlo.ts(21,35): error TS1147: Import declarations in an internal module cannot reference an external module.
+testGlo.ts(21,35): error TS2307: Cannot find external module 'mNonExported'.
 
 
-==== testGlo.ts (1 errors) ====
+==== testGlo.ts (4 errors) ====
     module m2 {
         export import mExported = require("mExported");
                                           ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                          ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mExported'.
         export var c1 = new mExported.me.class1;
         export function f1() {
             return new mExported.me.class1();
@@ -25,6 +30,10 @@ testGlo.ts(2,39): error TS1147: Import declarations in an internal module cannot
         }
     
         import mNonExported = require("mNonExported");
+                                      ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mNonExported'.
         export var c3 = new mNonExported.mne.class1;
         export function f3() {
             return new mNonExported.mne.class1();
diff --git a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/amd/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/amd/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt
index 8589da5c54d..820d18ffb98 100644
--- a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/amd/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt
+++ b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/amd/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt
@@ -1,7 +1,10 @@
 test.ts(5,39): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(5,39): error TS2307: Cannot find external module 'mExported'.
+test.ts(24,35): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(24,35): error TS2307: Cannot find external module 'mNonExported'.
 
 
-==== test.ts (1 errors) ====
+==== test.ts (4 errors) ====
     export module m1 {
     }
     
@@ -9,6 +12,8 @@ test.ts(5,39): error TS1147: Import declarations in an internal module cannot re
         export import mExported = require("mExported");
                                           ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                          ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mExported'.
         export var c1 = new mExported.me.class1;
         export function f1() {
             return new mExported.me.class1();
@@ -28,6 +33,10 @@ test.ts(5,39): error TS1147: Import declarations in an internal module cannot re
         }
     
         import mNonExported = require("mNonExported");
+                                      ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mNonExported'.
         export var c3 = new mNonExported.mne.class1;
         export function f3() {
             return new mNonExported.mne.class1();
diff --git a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/node/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/node/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt
index 8589da5c54d..820d18ffb98 100644
--- a/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/node/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt
+++ b/tests/baselines/reference/project/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule/node/privacyCheckOnImportedModuleDeclarationsInsideNonExportedModule.errors.txt
@@ -1,7 +1,10 @@
 test.ts(5,39): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(5,39): error TS2307: Cannot find external module 'mExported'.
+test.ts(24,35): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(24,35): error TS2307: Cannot find external module 'mNonExported'.
 
 
-==== test.ts (1 errors) ====
+==== test.ts (4 errors) ====
     export module m1 {
     }
     
@@ -9,6 +12,8 @@ test.ts(5,39): error TS1147: Import declarations in an internal module cannot re
         export import mExported = require("mExported");
                                           ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                          ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mExported'.
         export var c1 = new mExported.me.class1;
         export function f1() {
             return new mExported.me.class1();
@@ -28,6 +33,10 @@ test.ts(5,39): error TS1147: Import declarations in an internal module cannot re
         }
     
         import mNonExported = require("mNonExported");
+                                      ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mNonExported'.
         export var c3 = new mNonExported.mne.class1;
         export function f3() {
             return new mNonExported.mne.class1();
diff --git a/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/amd/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt b/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/amd/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt
index c3c3a11c8b2..ed865949b87 100644
--- a/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/amd/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt
+++ b/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/amd/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt
@@ -1,11 +1,16 @@
 test.ts(2,39): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(2,39): error TS2307: Cannot find external module 'mExported'.
+test.ts(42,35): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(42,35): error TS2307: Cannot find external module 'mNonExported'.
 
 
-==== test.ts (1 errors) ====
+==== test.ts (4 errors) ====
     export module m2 {
         export import mExported = require("mExported");
                                           ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                          ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mExported'.
     
         module Internal_M1 {
             export var c1 = new mExported.me.class1;
@@ -46,6 +51,10 @@ test.ts(2,39): error TS1147: Import declarations in an internal module cannot re
         }
     
         import mNonExported = require("mNonExported");
+                                      ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mNonExported'.
         module Internal_M3 {
             export var c3 = new mNonExported.mne.class1;
             export function f3() {
diff --git a/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/node/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt b/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/node/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt
index c3c3a11c8b2..ed865949b87 100644
--- a/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/node/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt
+++ b/tests/baselines/reference/project/privacyCheckOnImportedModuleImportStatementInParentModule/node/privacyCheckOnImportedModuleImportStatementInParentModule.errors.txt
@@ -1,11 +1,16 @@
 test.ts(2,39): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(2,39): error TS2307: Cannot find external module 'mExported'.
+test.ts(42,35): error TS1147: Import declarations in an internal module cannot reference an external module.
+test.ts(42,35): error TS2307: Cannot find external module 'mNonExported'.
 
 
-==== test.ts (1 errors) ====
+==== test.ts (4 errors) ====
     export module m2 {
         export import mExported = require("mExported");
                                           ~~~~~~~~~~~
 !!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                          ~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mExported'.
     
         module Internal_M1 {
             export var c1 = new mExported.me.class1;
@@ -46,6 +51,10 @@ test.ts(2,39): error TS1147: Import declarations in an internal module cannot re
         }
     
         import mNonExported = require("mNonExported");
+                                      ~~~~~~~~~~~~~~
+!!! error TS1147: Import declarations in an internal module cannot reference an external module.
+                                      ~~~~~~~~~~~~~~
+!!! error TS2307: Cannot find external module 'mNonExported'.
         module Internal_M3 {
             export var c3 = new mNonExported.mne.class1;
             export function f3() {
diff --git a/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt b/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt
index 10568608a79..c911886c670 100644
--- a/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt
+++ b/tests/baselines/reference/switchStatementsWithMultipleDefaults.errors.txt
@@ -1,8 +1,9 @@
 tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(9,5): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement.
 tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(21,13): error TS1113: A 'default' clause cannot appear more than once in a 'switch' statement.
+tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(28,22): error TS1108: A 'return' statement can only be used within a function body.
 
 
-==== tests/cases/compiler/switchStatementsWithMultipleDefaults.ts (2 errors) ====
+==== tests/cases/compiler/switchStatementsWithMultipleDefaults.ts (3 errors) ====
     
     var x = 10;
     
@@ -35,6 +36,8 @@ tests/cases/compiler/switchStatementsWithMultipleDefaults.ts(21,13): error TS111
                 def\u0061ult: // Error, fourth 'default' clause.
                 // Errors on fifth-seventh
                 default: return;
+                         ~~~~~~
+!!! error TS1108: A 'return' statement can only be used within a function body.
                 default: default:
             }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
index a9b9e45a33c..6b389218f65 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.errors.txt
@@ -7,15 +7,18 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(20,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(22,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(22,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,19): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(24,25): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,9): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(26,40): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(28,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(28,50): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts(28,57): error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
 
 
-==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts (15 errors) ====
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTypedTags.ts (18 errors) ====
     interface I {
         (stringParts: string[], ...rest: boolean[]): I;
         g: I;
@@ -58,18 +61,24 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithIncompatibleTyped
 !!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f `abc`[0].member `abc${1}def${2}ghi`;
+      ~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                       ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                             ~
 !!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
     
     f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+      ~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
             ~
 !!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'boolean'.
                                            ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
     f `abc${ true }def${ true }ghi`["member"].member `abc${ 1 }def${ 2 }ghi`;
+      ~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                                                      ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                                                             ~
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt
index 4ea0304f421..2557d6cc94a 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsWithTagsTypedAsAny.errors.txt
@@ -6,11 +6,13 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(13,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(15,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(17,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(19,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(19,32): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(21,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts(21,46): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 
 
-==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts (10 errors) ====
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts (12 errors) ====
     var f: any;
     
     f `abc`
@@ -46,10 +48,14 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithTagsTypedAsAny.ts
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
     f `abc`["member"].someOtherTag `abc${1}def${2}ghi`;
+      ~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                                    ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
     f `abc${1}def${2}ghi`["member"].someOtherTag `abc${1}def${2}ghi`;
+      ~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                                                  ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
diff --git a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt
index 173d3a6b741..28050ec96c1 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt
+++ b/tests/baselines/reference/taggedTemplateStringsWithTypedTags.errors.txt
@@ -4,11 +4,13 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(16,3
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(18,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(20,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(22,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(24,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(24,19): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
+tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(26,3): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(26,40): error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
 
 
-==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts (8 errors) ====
+==== tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts (10 errors) ====
     interface I {
         (stringParts: string[], ...rest: number[]): I;
         g: I;
@@ -45,10 +47,14 @@ tests/cases/conformance/es6/templates/taggedTemplateStringsWithTypedTags.ts(26,4
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
     f `abc`[0].member `abc${1}def${2}ghi`;
+      ~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                       ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
     f `abc${1}def${2}ghi`["member"].member `abc${1}def${2}ghi`;
+      ~~~~~~
+!!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
                                            ~~~~~~
 !!! error TS1159: Tagged templates are only available when targeting ECMAScript 6 and higher.
     
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
index 24d64d8f29e..7b28cf64ae9 100644
--- a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
+++ b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
@@ -1,11 +1,14 @@
 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 errors) ====
+==== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts (2 errors) ====
     function* gen() {
             ~
 !!! error TS9001: Generators are not currently supported.
         // 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
index 20542cb12b7..46ca3c74b95 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.errors.txt
@@ -1,11 +1,14 @@
 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 (1 errors) ====
+==== 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/yieldExpression1.errors.txt b/tests/baselines/reference/yieldExpression1.errors.txt
index 33d9c1bf62e..91a379e6172 100644
--- a/tests/baselines/reference/yieldExpression1.errors.txt
+++ b/tests/baselines/reference/yieldExpression1.errors.txt
@@ -1,9 +1,12 @@
 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 errors) ====
+==== tests/cases/compiler/yieldExpression1.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/cases/compiler/constDeclarations-invalidContexts.ts b/tests/cases/compiler/constDeclarations-invalidContexts.ts
index 3da91a7d1d7..b5093180990 100644
--- a/tests/cases/compiler/constDeclarations-invalidContexts.ts
+++ b/tests/cases/compiler/constDeclarations-invalidContexts.ts
@@ -15,7 +15,7 @@ while (true);
 
 var obj;
 with (obj) 
-    const c5 = 0;
+    const c5 = 0;  // No  Error will be reported here since we turn off all type checking
 
 for (var i = 0; i < 10; i++)
     const c6 = 0;
diff --git a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts
new file mode 100644
index 00000000000..9ef2f06cdfc
--- /dev/null
+++ b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment1.ts
@@ -0,0 +1,3 @@
+function foo(obj: { name?: string; id: number }) { }
+var name:any, id: any;
+foo({ name?, id? });
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment2.ts b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment2.ts
new file mode 100644
index 00000000000..ca28c05016b
--- /dev/null
+++ b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment2.ts
@@ -0,0 +1 @@
+var v = { class };
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment3.ts b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment3.ts
new file mode 100644
index 00000000000..de2a94b194e
--- /dev/null
+++ b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment3.ts
@@ -0,0 +1 @@
+var v = { "" };
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment4.ts b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment4.ts
new file mode 100644
index 00000000000..5479b23b32b
--- /dev/null
+++ b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment4.ts
@@ -0,0 +1 @@
+var v = { 0 };
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment5.ts b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment5.ts
new file mode 100644
index 00000000000..8f8e7902cd4
--- /dev/null
+++ b/tests/cases/conformance/parser/ecmascript6/ShorthandPropertyAssignment/parserShorthandPropertyAssignment5.ts
@@ -0,0 +1,2 @@
+var greet = "hello";
+var obj = { greet? }; 
\ No newline at end of file