Parser fix for lambdas

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 870 matching lines @@
 ListFactory = Array;
 ListFactory.prototype.is$ListFactory = function(){return this;};
 ListFactory.prototype.is$List = function(){return this;};
 ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
 ListFactory.prototype.is$List$Definition = function(){return this;};
 ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
 ListFactory.prototype.is$List$GlobalValue = function(){return this;};
 ListFactory.prototype.is$List$HInstruction = function(){return this;};
 ListFactory.prototype.is$List$Member = function(){return this;};
 ListFactory.prototype.is$List$String = function(){return this;};
+ListFactory.prototype.is$List$Token = function(){return this;};
 ListFactory.prototype.is$List$Type = function(){return this;};
 ListFactory.prototype.is$List$Value = function(){return this;};
 ListFactory.prototype.is$List$int = function(){return this;};
 ListFactory.prototype.is$Collection$E = function(){return this;};
 ListFactory.prototype.is$Collection$Object = function(){return this;};
 ListFactory.prototype.is$Collection$Type = function(){return this;};
 ListFactory.prototype.is$Iterable = function(){return this;};
 ListFactory.ListFactory$from$factory = function(other) {
   var list = [];
   for (var $i = other.iterator(); $i.hasNext$0(); ) {
@@ skipping 12353 matching lines @@
     this.isInitializer = true;
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(method.get$isStatic()) && $notnull_bool(this.type.get$hasTypeParams())) {
     $globals.world.error('using type parameter in static context', this.definition.span);
   }
   if (this.definition.value != null) {
     if ((this.definition.value instanceof NullExpression) && this.definition.value.span.start == this.definition.span.start) {
       return;
     }
-    if ($notnull_bool(method.get$isAbstract())) {
+    if (method.name == '\$call') {
+      if ($notnull_bool(method.get$definition().get$body() == null)) {
+        $globals.world.error('default value not allowed on function type', this.definition.span);
+      }
+    }
+    else if ($notnull_bool(method.get$isAbstract())) {
       $globals.world.error('default value not allowed on abstract methods', this.definition.span);
     }
-    else if (method.name == '\$call' && $notnull_bool(method.get$definition().get$body() == null)) {
-      $globals.world.error('default value not allowed on function type', this.definition.span);
-    }
   }
   else if ($notnull_bool(this.isInitializer) && !$notnull_bool(method.get$isConstructor())) {
     $globals.world.error('initializer parameters only allowed on constructors', this.definition.span);
   }
 }
 Parameter.prototype.genValue = function(method, context) {
   var $0;
   if (this.definition.value == null || this.value != null) return;
   if (context == null) {
     context = new MethodGenerator(method, null);
@@ skipping 129 matching lines @@
     $globals.world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     $globals.world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
-  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 201, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 203, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if (this.name == '') {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + this.name + '\$factory');
   }
 }
 Member.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
@@ skipping 804 matching lines @@
   if ($notnull_bool(this.get$isConstructor())) {
     return this._invokeConstructor(context, node, target, args, argsString);
   }
   if ($notnull_bool(target.isSuper)) {
     return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.get$isOperator())) {
     return this._invokeBuiltin(context, node, target, args, argsCode, isDynamic);
   }
   if ($notnull_bool(this.isFactory)) {
-    $assert(target.isType, "target.isType", "member.dart", 958, 14);
+    $assert(target.isType, "target.isType", "member.dart", 960, 14);
     return new Value(target.type, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.get$inferredResult(), ('' + this.get$jsname() + '(' + argsString + ')'), node != null ? node.span : node, true);
     }
     return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if ($notnull_bool(target.get$isConst())) {
@@ skipping 741 matching lines @@
   return this.getFactory($assert_String($0), $assert_String($1));
 };
 // ********** Code for lang_Token **************
 function lang_Token(kind, source, start, end) {
   this.kind = kind;
   this.source = source;
   this.start = start;
   this.end = end;
   // Initializers done
 }
+lang_Token.prototype.is$lang_Token = function(){return this;};
 lang_Token.prototype.get$kind = function() { return this.kind; };
 lang_Token.prototype.get$source = function() { return this.source; };
 lang_Token.prototype.get$end = function() { return this.end; };
 lang_Token.prototype.get$start = function() { return this.start; };
 lang_Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 lang_Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
@@ skipping 345 matching lines @@
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
   if (this._interpStack != null) {
     if (this._interpStack.depth == -1) {
       this._interpStack.depth = 1;
     }
     else {
-      $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 270, 16);
+      $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 277, 16);
       ($0 = this._interpStack).depth = $0.depth + 1;
     }
   }
   return this._finishToken(6/*TokenKind.LBRACE*/);
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
   if (this._interpStack != null) {
     ($0 = this._interpStack).depth = $0.depth - 1;
-    $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 280, 14);
+    $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 287, 14);
   }
   return this._finishToken(7/*TokenKind.RBRACE*/);
 }
 TokenizerBase.prototype.finishString = function(quote) {
   if ($notnull_bool(this._maybeEatChar(quote))) {
     if ($notnull_bool(this._maybeEatChar(quote))) {
       return this.finishMultilineString(quote);
     }
     else {
       return this._finishToken(58/*TokenKind.STRING*/);
@@ skipping 1480 matching lines @@
 }
 TokenKind.kindFromAssign = function(kind) {
   if (kind == 20/*TokenKind.ASSIGN*/) return 0;
   if (kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/) {
     return kind + (15)/*(ADD - ASSIGN_ADD)*/;
   }
   return -1;
 }
 // ********** Code for lang_Parser **************
 function lang_Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
+  var $0;
+  this._afterParensIndex = 0
   this.source = source;
   this.diet = diet;
   this.throwOnIncomplete = throwOnIncomplete;
   this.optionalSemicolons = optionalSemicolons;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
-  this._peekToken = this.tokenizer.next();
+  this._peekToken = (($0 = this.tokenizer.next()) && $0.is$lang_Token());
   this._previousToken = null;
   this._inInitializers = false;
+  this._afterParens = [];
 }
 lang_Parser.prototype.get$source = function() { return this.source; };
 lang_Parser.prototype.isPrematureEndOfFile = function() {
   if ($notnull_bool(this.throwOnIncomplete) && $notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/)) || $notnull_bool(this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/)) || $notnull_bool(this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/))) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
   else if ($notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
 lang_Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
 lang_Parser.prototype._lang_next = function() {
+  var $0;
   this._previousToken = this._peekToken;
-  this._peekToken = this.tokenizer.next();
+  this._peekToken = (($0 = this.tokenizer.next()) && $0.is$lang_Token());
   return this._previousToken;
 }
 lang_Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
 lang_Parser.prototype._peekIdentifier = function() {
   return TokenKind.isIdentifier(this._peekToken.kind);
 }
 lang_Parser.prototype._maybeEat = function(kind) {
+  var $0;
   if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
-    this._peekToken = this.tokenizer.next();
+    this._peekToken = (($0 = this.tokenizer.next()) && $0.is$lang_Token());
     return true;
   }
   else {
     return false;
   }
 }
 lang_Parser.prototype._eat = function(kind) {
   if (!$notnull_bool(this._maybeEat(kind))) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
@@ skipping 369 matching lines @@
       value = this.expression();
     }
     return this.finishField(expr.get$span().get$start(), null, gt, name, value);
   }
   else {
     this._eatSemicolon();
     return new lang_ExpressionStatement(expr, this._makeSpan($assert_num(expr.get$span().get$start())));
   }
 }
 lang_Parser.prototype.testCondition = function() {
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eatLeftParen();
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return (ret && ret.is$lang_Expression());
 }
 lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
   while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
@@ skipping 29 matching lines @@
   this._eat(94/*TokenKind.DO*/);
   var body = this.statement();
   this._eat(114/*TokenKind.WHILE*/);
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
 lang_Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(99/*TokenKind.FOR*/);
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eatLeftParen();
   var init = this.forInitializerStatement(start);
   if ((init instanceof ForInStatement)) {
     return init;
   }
   var test = null;
   if (!$notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
@@ skipping 46 matching lines @@
   }
   var finallyBlock = null;
   if ($notnull_bool(this._maybeEat(98/*TokenKind.FINALLY*/))) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
 lang_Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
   this._eat(90/*TokenKind.CATCH*/);
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eatLeftParen();
   var exc = this.declaredIdentifier(false);
   var trace = null;
   if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
     trace = this.declaredIdentifier(false);
   }
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.block();
   return new CatchNode(exc, trace, body, this._makeSpan(start));
 }
 lang_Parser.prototype.switchStatement = function() {
@@ skipping 64 matching lines @@
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ThrowStatement(expr, this._makeSpan(start));
 }
 lang_Parser.prototype.assertStatement = function() {
   var start = this._peekToken.start;
   this._eat(72/*TokenKind.ASSERT*/);
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eatLeftParen();
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   this._eatSemicolon();
   return new AssertStatement(expr, this._makeSpan(start));
 }
 lang_Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
   this._eat(88/*TokenKind.BREAK*/);
   var name = null;
   if ($notnull_bool(this._peekIdentifier())) {
@@ skipping 38 matching lines @@
 }
 lang_Parser.prototype.infixExpression = function(precedence) {
   var $0;
   return this.finishInfixExpression((($0 = this.unaryExpression()) && $0.is$lang_Expression()), precedence);
 }
 lang_Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan($assert_num(type.get$span().get$start()))));
 }
 lang_Parser.prototype._fixAsType = function(x) {
-  $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 790, 12);
+  $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 799, 12);
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
     var type = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
     return this._finishDeclaredId(type);
   }
   else {
-    $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 801, 14);
+    $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 810, 14);
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments((paramBase && paramBase.is$TypeReference()), 1);
     var type;
     if (firstParam.get$depth() <= 0) {
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       type = this._finishTypeArguments((base && base.is$TypeReference()), 0, [firstParam]);
     }
@@ skipping 72 matching lines @@
   }
   expr = this.expression();
   if (label == null && $notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
 lang_Parser.prototype.arguments = function() {
   var args = [];
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eatLeftParen();
   if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     do {
       args.add$1(this.argument());
     }
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return args;
 }
 lang_Parser.prototype.get$arguments = function() {
   return lang_Parser.prototype.arguments.bind(this);
 }
 lang_Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
-      return this.finishPostfixExpression(new CallExpression(expr, this.arguments(), this._makeSpan($assert_num(expr.get$span().get$start()))));
+      return this.finishCallOrLambdaExpression(expr);
 
     case 4/*TokenKind.LBRACK*/:
 
       this._eat(4/*TokenKind.LBRACK*/);
       var index = this.expression();
       this._eat(5/*TokenKind.RBRACK*/);
       return this.finishPostfixExpression(new IndexExpression(expr, index, this._makeSpan($assert_num(expr.get$span().get$start()))));
 
     case 14/*TokenKind.DOT*/:
 
       this._eat(14/*TokenKind.DOT*/);
       var name = this.identifier();
       var ret = new DotExpression(expr, name, this._makeSpan($assert_num(expr.get$span().get$start())));
       return this.finishPostfixExpression(ret);
 
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       var tok = this._lang_next();
       return new PostfixExpression(expr, tok, this._makeSpan($assert_num(expr.get$span().get$start())));
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
-      if ($notnull_bool(this._inInitializers)) return expr;
-      var body = this.functionBody(true);
-      return this._makeFunction(expr, body);
+      return expr;
 
     default:
 
       if ($notnull_bool(this._peekIdentifier())) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan($assert_num(expr.get$span().get$start()))));
       }
       else {
         return expr;
       }
 
   }
 }
+lang_Parser.prototype.finishCallOrLambdaExpression = function(expr) {
+  if ($notnull_bool(this._atClosureParameters())) {
+    var formals = this.formalParameterList();
+    var body = this.functionBody(true);
+    return this._makeFunction(expr, formals, body);
+  }
+  else {
+    var args = this.arguments();
+    return this.finishPostfixExpression(new CallExpression(expr, args, this._makeSpan($assert_num(expr.get$span().get$start()))));
+  }
+}
 lang_Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && $notnull_bool($eq(expr.get$op().get$kind(), kind));
 }
 lang_Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, $globals.world.nonNullBool);
 }
 lang_Parser.prototype._intTypeRef = function(span) {
   return new TypeReference(span, $globals.world.intType);
 }
 lang_Parser.prototype._doubleTypeRef = function(span) {
@@ skipping 168 matching lines @@
   }
   else if ($notnull_bool($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 lang_Parser.prototype._parenOrLambda = function() {
   var $0;
   var start = this._peekToken.start;
-  var args = this.arguments();
-  if (!$notnull_bool(this._inInitializers) && ($notnull_bool(this._peekKind(9/*TokenKind.ARROW*/)) || $notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/)))) {
+  if ($notnull_bool(this._atClosureParameters())) {
+    var formals = this.formalParameterList();
     var body = this.functionBody(true);
-    var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
     return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   else {
+    var saved = this._inInitializers;
+    this._inInitializers = false;
+    var args = this.arguments();
+    this._inInitializers = $assert_bool(saved);
     if ($notnull_bool($eq(args.length, 1))) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
       this._lang_error('unexpected comma expression');
       return args.$index(0).get$value();
     }
   }
 }
+lang_Parser.prototype._atClosureParameters = function() {
+  if ($notnull_bool(this._inInitializers)) return false;
+  var after = this._peekAfterCloseParen();
+  return after.kind == 9/*TokenKind.ARROW*/ || after.kind == 6/*TokenKind.LBRACE*/;
+}
+lang_Parser.prototype._eatLeftParen = function() {
+  this._eat(2/*TokenKind.LPAREN*/);
+  this._afterParensIndex++;
+}
+lang_Parser.prototype._peekAfterCloseParen = function() {
+  var $0;
+  if (this._afterParensIndex < this._afterParens.length) {
+    return (($0 = this._afterParens.$index(this._afterParensIndex)) && $0.is$lang_Token());
+  }
+  this._afterParensIndex = 0;
+  this._afterParens.clear();
+  var tokens = [this._lang_next()];
+  this._lookaheadAfterParens((tokens && tokens.is$List$Token()));
+  var after = this._peekToken;
+  tokens.add$1(after);
+  this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
+  this._lang_next();
+  return (after && after.is$lang_Token());
+}
+lang_Parser.prototype._lookaheadAfterParens = function(tokens) {
+  var saved = this._afterParens.length;
+  this._afterParens.add(null);
+  while (true) {
+    var token = this._lang_next();
+    tokens.add(token);
+    var kind = token.kind;
+    if (kind == 3/*TokenKind.RPAREN*/ || kind == 1/*TokenKind.END_OF_FILE*/) {
+      this._afterParens.$setindex(saved, this._peekToken);
+      return;
+    }
+    else if (kind == 2/*TokenKind.LPAREN*/) {
+      this._lookaheadAfterParens(tokens);
+    }
+  }
+}
 lang_Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
 }
 lang_Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case 15/*TokenKind.ELLIPSIS*/:
 
       this._eat(15/*TokenKind.ELLIPSIS*/);
@@ skipping 92 matching lines @@
   }
   else {
     return -1;
   }
 }
 lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    i < hex.length; i++) {
     var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
-    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1261, 14);
+    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1335, 14);
     result = (result << 4) + $assert_num(digit);
   }
   return $assert_num(result);
 }
 lang_Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
@@ skipping 206 matching lines @@
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   if ($notnull_bool(inOptionalBlock) && $notnull_bool(value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
-  this._eat(2/*TokenKind.LPAREN*/);
+  this._eatLeftParen();
   var formals = [];
   var inOptionalBlock = false;
   if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
       inOptionalBlock = true;
     }
     formals.add$1(this.formalParameter($assert_bool(inOptionalBlock)));
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
         if ($notnull_bool(inOptionalBlock)) {
@@ skipping 11 matching lines @@
   return formals;
 }
 lang_Parser.prototype.identifier = function() {
   var $0;
   var tok = this._lang_next();
   if (!$notnull_bool(TokenKind.isIdentifier($assert_num(tok.get$kind())))) {
     this._lang_error(('expected identifier, but found ' + tok), (($0 = tok.get$span()) && $0.is$SourceSpan()));
   }
   return new lang_Identifier(tok.get$text(), this._makeSpan($assert_num(tok.get$start())));
 }
-lang_Parser.prototype._makeFunction = function(expr, body) {
+lang_Parser.prototype._makeFunction = function(expr, formals, body) {
   var $0;
   var name, type;
-  if ((expr instanceof CallExpression)) {
-    if ((expr.get$target() instanceof VarExpression)) {
-      name = expr.get$target().get$name();
-      type = null;
-    }
-    else if ((expr.get$target() instanceof DeclaredIdentifier)) {
-      name = expr.get$target().get$name();
-      type = expr.get$target().get$type();
-    }
-    else {
-      this._lang_error('bad function');
-    }
-    var formals = this._makeFormals(expr.get$arguments());
-    var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
-    var func = new FunctionDefinition(null, type, name, formals, null, body, (span && span.is$SourceSpan()));
-    return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
+  if ((expr instanceof VarExpression)) {
+    name = expr.get$name();
+    type = null;
+  }
+  else if ((expr instanceof DeclaredIdentifier)) {
+    name = expr.get$name();
+    type = expr.get$type();
   }
   else {
-    this._lang_error('expected function');
+    this._lang_error('bad function body', (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
-}
-lang_Parser.prototype._makeFormal = function(expr) {
-  var $0;
-  if ((expr instanceof VarExpression)) {
-    return new FormalNode(false, false, null, expr.get$name(), null, (($0 = expr.get$span()) && $0.is$SourceSpan()));
-  }
-  else if ((expr instanceof DeclaredIdentifier)) {
-    return new FormalNode(false, false, expr.get$type(), expr.get$name(), null, (($0 = expr.get$span()) && $0.is$SourceSpan()));
-  }
-  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/)) && ((expr.get$x() instanceof DeclaredIdentifier))) {
-    var di = (($0 = expr.get$x()) && $0.is$DeclaredIdentifier());
-    return new FormalNode(false, false, di.type, di.name, expr.get$y(), (($0 = expr.get$span()) && $0.is$SourceSpan()));
-  }
-  else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/))) {
-    return null;
-  }
-  else if ((expr instanceof ListExpression)) {
-    return this._makeFormalsFromList(expr);
-  }
-  else {
-    this._lang_error('expected formal', (($0 = expr.get$span()) && $0.is$SourceSpan()));
-  }
-}
-lang_Parser.prototype._makeFormalsFromList = function(expr) {
-  var $0;
-  if ($notnull_bool(expr.get$isConst())) {
-    this._lang_error('expected formal, but found "const"', (($0 = expr.get$span()) && $0.is$SourceSpan()));
-  }
-  else if ($notnull_bool($ne(expr.get$type(), null))) {
-    this._lang_error('expected formal, but found generic type arguments', (($0 = expr.get$type().get$span()) && $0.is$SourceSpan()));
-  }
-  return this._makeFormalsFromExpressions(expr.get$values(), false);
-}
-lang_Parser.prototype._makeFormals = function(arguments) {
-  var expressions = [];
-  for (var i = 0;
-   i < $assert_num(arguments.length); i++) {
-    var arg = arguments.$index(i);
-    if ($notnull_bool($ne(arg.get$label(), null))) {
-      this._lang_error('expected formal, but found ":"');
-    }
-    expressions.add$1(arg.get$value());
-  }
-  return this._makeFormalsFromExpressions(expressions, true);
-}
-lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
-  var $0;
-  var formals = [];
-  for (var i = 0;
-   i < $assert_num(expressions.length); i++) {
-    var formal = this._makeFormal(expressions.$index(i));
-    if ($notnull_bool(formal == null)) {
-      var baseType = this._makeType(expressions.$index(i).get$x());
-      var typeParams = [this._makeType(expressions.$index(i).get$y())];
-      i++;
-      while (i < $assert_num(expressions.length)) {
-        var expr = expressions.$index(i++);
-        if ($notnull_bool(this._isBin(expr, 53/*TokenKind.GT*/))) {
-          typeParams.add$1(this._makeType(expr.get$x()));
-          var type = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan($assert_num(baseType.get$span().get$start())));
-          var name = null;
-          if ((expr.get$y() instanceof VarExpression)) {
-            var ve = (($0 = expr.get$y()) && $0.is$VarExpression());
-            name = ve.name;
-          }
-          else {
-            this._lang_error('expected formal', (($0 = expr.get$span()) && $0.is$SourceSpan()));
-          }
-          formal = new FormalNode(false, false, type, name, null, this._makeSpan($assert_num(expressions.$index(0).get$span().get$start())));
-          break;
-        }
-        else {
-          typeParams.add$1(this._makeType(expr));
-        }
-      }
-      formals.add$1(formal);
-    }
-    else if (!!(formal && formal.is$List)) {
-      formals.addAll$1(formal);
-      if (!$notnull_bool(allowOptional)) {
-        this._lang_error('unexpected nested optional formal', (($0 = expressions.$index(i).get$span()) && $0.is$SourceSpan()));
-      }
-    }
-    else {
-      formals.add$1(formal);
-    }
-  }
-  return formals;
+  var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
+  var func = new FunctionDefinition(null, type, name, formals, null, body, (span && span.is$SourceSpan()));
+  return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
 }
 lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
   var $0;
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), (($0 = e.get$span()) && $0.is$SourceSpan()));
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
@@ skipping 18 matching lines @@
   this.token = token;
   // Initializers done
 }
 IncompleteSourceException.prototype.toString = function() {
   if (this.token.get$span() == null) return ('Unexpected ' + this.token);
   return $assert_String(this.token.get$span().toMessageString(('Unexpected ' + this.token)));
 }
 IncompleteSourceException.prototype.toString$0 = function() {
   return this.toString();
 };
+// ********** Code for DivertedTokenSource **************
+function DivertedTokenSource(tokens, parser, previousTokenizer) {
+  this._lang_pos = 0
+  this.tokens = tokens;
+  this.parser = parser;
+  this.previousTokenizer = previousTokenizer;
+  // Initializers done
+}
+DivertedTokenSource.prototype.next = function() {
+  var token = this.tokens.$index(this._lang_pos);
+  ++this._lang_pos;
+  if (this._lang_pos == this.tokens.length) {
+    this.parser.tokenizer = this.previousTokenizer;
+  }
+  return token;
+}
+DivertedTokenSource.prototype.next$0 = function() {
+  return this.next();
+};
 // ********** Code for lang_Node **************
 function lang_Node(span) {
   this.span = span;
   // Initializers done
 }
 lang_Node.prototype.is$lang_Node = function(){return this;};
 lang_Node.prototype.get$span = function() { return this.span; };
 lang_Node.prototype.set$span = function(value) { return this.span = value; };
 lang_Node.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
@@ skipping 4005 matching lines @@
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 var $globals = {};
 $static_init();
 main();