Merge branch 'master' into postEditInvariants

Conflicts:
	src/harness/test262Runner.ts

src/compiler/parser.ts

@@ -856,7 +856,7 @@ module ts {
             // flag so that we don't mark any subsequent nodes.
             if (parseErrorBeforeNextFinishedNode) {
                 parseErrorBeforeNextFinishedNode = false;
-                node.parserContextFlags |= ParserContextFlags.ContainsError;
+                node.parserContextFlags |= ParserContextFlags.ThisNodeHasError;
             }
 
             return node;

src/compiler/types.ts

@@ -317,14 +317,22 @@ module ts {
 
         // If the parser encountered an error when parsing the code that created this node.  Note
         // the parser only sets this directly on the node it creates right after encountering the
-        // error.  We then propagate that flag upwards to parent nodes during incremental parsing.
-        ContainsError = 1 << 4,
+        // error.  
+        ThisNodeHasError = 1 << 4,
+
+        // Context flags set directly by the parser.
+        ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | ThisNodeHasError,
+
+        // Context flags computed by aggregating child flags upwards.
+
+        // If this node, or any of it's children (transitively) contain an error.  
+        ThisNodeOrAnySubNodesHasError = 1 << 5,
 
         // Used during incremental parsing to determine if we need to visit this node to see if
         // any of its children had an error.  Once we compute that once, we can set this bit on the
         // node to know that we never have to do it again.  From that point on, we can just check
         // the node directly for 'ContainsError'.
-        HasPropagatedChildContainsErrorFlag = 1 << 5
+        HasComputedThisNodeOrAnySubNodesHasError = 1 << 6
     }
 
     export interface Node extends TextRange {

src/compiler/utilities.ts

@@ -68,25 +68,25 @@ module ts {
 
     // Returns true if this node contains a parse error anywhere underneath it.
     export function containsParseError(node: Node): boolean {
-        if (!hasFlag(node.parserContextFlags, ParserContextFlags.HasPropagatedChildContainsErrorFlag)) {
+        if (!hasFlag(node.parserContextFlags, ParserContextFlags.HasComputedThisNodeOrAnySubNodesHasError)) {
             // A node is considered to contain a parse error if:
             //  a) the parser explicitly marked that it had an error
             //  b) any of it's children reported that it had an error.
-            var val = hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError) ||
+            var val = hasFlag(node.parserContextFlags, ParserContextFlags.ThisNodeHasError) ||
                 forEachChild(node, containsParseError);
 
             // If so, mark ourselves accordingly. 
             if (val) {
-                node.parserContextFlags |= ParserContextFlags.ContainsError;
+                node.parserContextFlags |= ParserContextFlags.ThisNodeOrAnySubNodesHasError;
             }
 
             // Also mark that we've propogated the child information to this node.  This way we can
             // always consult the bit directly on this node without needing to check its children
             // again.
-            node.parserContextFlags |= ParserContextFlags.HasPropagatedChildContainsErrorFlag;
+            node.parserContextFlags |= ParserContextFlags.HasComputedThisNodeOrAnySubNodesHasError;
         }
 
-        return hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError);
+        return hasFlag(node.parserContextFlags, ParserContextFlags.ThisNodeOrAnySubNodesHasError);
     }
 
     export function getSourceFileOfNode(node: Node): SourceFile {

src/harness/harness.ts

@@ -224,7 +224,12 @@ module Utils {
         }
 
         function getNodeFlagName(f: number) { return getFlagName((<any>ts).NodeFlags, f); }
-        function getParserContextFlagName(f: number) { return getFlagName((<any>ts).ParserContextFlags, f); }
+        function getParserContextFlagName(f: number) {
+            // Clear the flag that are produced by aggregating child values..  That is ephemeral 
+            // data we don't care about in the dump.  We only care what the parser set directly
+            // on the ast.
+            return getFlagName((<any>ts).ParserContextFlags, f & ts.ParserContextFlags.ParserGeneratedFlags);
+        }
 
         function serializeNode(n: ts.Node): any {
             var o: any = { kind: getKindName(n.kind) };