Allow error-recovery in top-level nodes.

dart/frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 5495 matching lines @@
       default:
 
         previous = token;
         token = this.next(token);
         break;
 
     }
   }
   token = this.parseIdentifier(previous);
   var isField;
-  if ($notnull_bool(this.optional('(', token))) {
-    isField = false;
-  }
-  else if ($notnull_bool(this.optional('=', token) || this.optional(';', token))) {
-    isField = true;
-  }
-  else {
-    token = this.listener.unexpected(token);
+  while ($notnull_bool(true)) {
+    if ($notnull_bool(this.optional('(', token))) {
+      isField = false;
+      break;
+    }
+    else if ($notnull_bool(this.optional('=', token) || this.optional(';', token))) {
+      isField = true;
+      break;
+    }
+    else {
+      token = this.listener.unexpected(token);
+    }
   }
   while ($notnull_bool(token != null && token.kind !== 123/*null.LBRACE_TOKEN*/ && token.kind !== 59/*null.SEMICOLON_TOKEN*/)) {
     token = this.next(token);
   }
   if ($notnull_bool(!$notnull_bool(this.optional(';', token)))) {
     token = this.skipBlock(token);
   }
   if ($notnull_bool(isField)) {
     this.listener.endTopLevelField(start, token);
   }
@@ skipping 80 matching lines @@
       return this.parseExpressionStatement(token);
 
   }
 }
 BodyParser.prototype.expectSemicolon = function(token) {
   return this.expect(';', token);
 }
 BodyParser.prototype.parseReturnStatement = function(token) {
   var begin = token;
   this.listener.beginReturnStatement(begin);
-  $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 407, 12);
+  $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 413, 12);
   token = this.parseExpression(this.next(token));
   this.listener.endReturnStatement(true, begin, token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseExpressionStatementOrDeclaration = function(token) {
-  $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 414, 12);
+  $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 420, 12);
   var peek1 = this.next(token);
   if ($notnull_bool(peek1.kind === 97/*null.IDENTIFIER_TOKEN*/)) {
     return this.parseLocalDeclaration(token, peek1);
   }
   else {
     return this.parseExpressionStatement(token);
   }
 }
 BodyParser.prototype.parseLocalDeclaration = function(token, peek1) {
   var peek2 = this.next(peek1);
@@ skipping 28 matching lines @@
     var question = token;
     token = this.parseExpression(this.next(token));
     var colon = token;
     token = this.expect(':', token);
     token = this.parseExpression(token);
     this.listener.handleConditionalExpression(question, colon);
   }
   return token;
 }
 BodyParser.prototype.parseBinaryExpression = function(token, precedence) {
-  $assert(precedence >= 4, "precedence >= 4", "parser.dart", 467, 12);
+  $assert(precedence >= 4, "precedence >= 4", "parser.dart", 473, 12);
   token = this.parsePrimary(token);
   var tokenLevel = this.getPrecedence(token);
   for (var level = $assert_num(tokenLevel);
    $notnull_bool(level >= precedence); --level) {
     while ($notnull_bool(tokenLevel === level)) {
       var operator = token;
       token = this.parseBinaryExpression(this.next(token), level + 1);
       this.listener.handleBinaryExpression(operator);
       tokenLevel = this.getPrecedence(token);
     }
@@ skipping 244 matching lines @@
     this.listener.handleNoArguments(token);
     return token;
   }
   else {
     return this.parseArguments(token);
   }
 }
 BodyParser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments(begin);
-  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 600, 12);
+  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 606, 12);
   var argumentCount = 0;
   if ($notnull_bool(this.optional(')', token.next))) {
     this.listener.endArguments(argumentCount, begin, token.next);
     return token.next.next;
   }
   do {
     token = this.parseExpression(this.next(token));
     ++argumentCount;
   }
   while ($notnull_bool(this.optional(',', token)))
@@ skipping 518 matching lines @@
   this.pushNode(new TypeAnnotation((($0 = this.popNode()) && $0.is$Identifier())));
 }
 BodyListener.prototype.endThrowStatement = function(throwToken, endToken) {
   var $0;
   var expression = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new Throw(expression, throwToken, endToken));
 }
 BodyListener.prototype.endRethrowStatement = function(throwToken, endToken) {
   this.pushNode(new Throw(null, throwToken, endToken));
 }
+BodyListener.prototype.handleNoType = function(token) {
+  this.pushNode(null);
+}
 BodyListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes = const$228/*const EmptyLink()*/;
   for (; $notnull_bool(count > 0); --count) {
     nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link$Node());
   }
   var sourceDelimiter = (($0 = $notnull_bool((delimiter == null)) ? null : new StringWrapper(delimiter)) && $0.is$SourceString());
   return new NodeList(beginToken, nodes, endToken, sourceDelimiter);
 }
 BodyListener.prototype.log = function(message) {
@@ skipping 13591 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);