Peek past balanced parens to see if they are an expression or lambda.

frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 394 matching lines @@
 }
 Math.min = function(a, b) {
   if (a == b) return a;
     if (a < b) {
       if (isNaN(b)) return b;
       else return a;
     }
     if (isNaN(a)) return a;
     else return b;
 }
-// ********** Code for Dispatcher **************
-function Dispatcher() {}
 // ********** Code for Strings **************
 function Strings() {}
 Strings.String$fromCharCodes$factory = function(charCodes) {
   return StringBase.createFromCharCodes(charCodes);
 }
 Strings.join = function(strings, separator) {
   return StringBase.join(strings, separator);
 }
 // ********** Code for top level **************
 function print(obj) {
@@ skipping 51 matching lines @@
 ListFactory$DoubleLinkedQueueEntry$KeyValuePair$K$V = ListFactory;
 ListFactory$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword = ListFactory;
 ListFactory$E = ListFactory;
 ListFactory$Element = ListFactory;
 ListFactory$HInstruction = ListFactory;
 ListFactory$K = ListFactory;
 ListFactory$KeywordState = ListFactory;
 ListFactory$SplayTreeNode$K$V = ListFactory;
 ListFactory$String = ListFactory;
 ListFactory$T = ListFactory;
+ListFactory$Token = ListFactory;
 ListFactory$V = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
@@ skipping 501 matching lines @@
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, HashMapImplementation);
 HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
+// ********** Code for HashMapImplementation$int$Token **************
+function HashMapImplementation$int$Token() {
+  // Initializers done
+  if (HashMapImplementation._deletedKey == null) {
+    HashMapImplementation._deletedKey = new Object();
+  }
+  this._numberOfEntries = 0;
+  this._numberOfDeleted = 0;
+  this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  this._values = new ListFactory$Token(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+}
+$inherits(HashMapImplementation$int$Token, HashMapImplementation);
+HashMapImplementation$int$Token._computeLoadLimit = function(capacity) {
+  return $truncdiv((capacity * 3), 4);
+}
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
   var set = new HashSetImplementation();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     set.add(e);
@@ skipping 10620 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, startOffset) {
+  this._highestCachePosition = -1
   this.source = source;
   this.diet = diet;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
+  this._afterCloseParenCache = new HashMapImplementation$int$Token();
 }
 lang_Parser.prototype.isPrematureEndOfFile = function() {
   if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
@@ skipping 753 matching lines @@
   this._eat(2/*TokenKind.LPAREN*/);
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     do {
       args.add(this.argument());
     }
     while (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(expr.get$span().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(expr.get$span().start)));
 
     case 14/*TokenKind.DOT*/:
 
       this._eat(14/*TokenKind.DOT*/);
       var name = this.identifier();
       var ret = new DotExpression(expr, name, this._makeSpan(expr.get$span().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(expr.get$span().start));
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
-      if (this._inInitializers) return expr;
-      var body = this.functionBody(true);
-      return this._makeFunction(expr, body);
+      return expr;
 
     default:
 
       if (this._peekIdentifier()) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
       }
       else {
         return expr;
       }
 
   }
 }
+lang_Parser.prototype.finishCallOrLambdaExpression = function(expr) {
+  if (!this._inInitializers && 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(expr.get$span().start)));
+  }
+}
 lang_Parser.prototype._isBin = function(expr, kind) {
   return (expr instanceof BinaryExpression) && expr.op.kind == kind;
 }
 lang_Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.boolType);
 }
 lang_Parser.prototype._numTypeRef = function(span) {
   return new TypeReference(span, world.numType);
 }
 lang_Parser.prototype._stringTypeRef = function(span) {
@@ skipping 154 matching lines @@
     this._errorExpected('string literal, but found interpolated string start');
   }
   else if ($eq(kind, 65/*TokenKind.INCOMPLETE_STRING*/)) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 lang_Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
-  var args = this.arguments();
-  if (!this._inInitializers && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/))) {
+  if (!this._inInitializers && 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, func.get$span());
   }
   else {
+    var args = this.arguments();
     if (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() {
+  var afterCloseParen = this._peekPastCloseParen();
+  return afterCloseParen.kind == 9/*TokenKind.ARROW*/ || afterCloseParen.kind == 6/*TokenKind.LBRACE*/;
+}
+lang_Parser.prototype._peekPastCloseParen = function() {
+  var pos = this._peekToken.start;
+  if (pos > this._highestCachePosition) return this._fillAfterCloseParenCache();
+  return this._afterCloseParenCache.$index(pos);
+}
+lang_Parser.prototype._fillAfterCloseParenCache = function() {
+  var tokens = [];
+  var positions = [];
+  var firstOpenParen = this._peekToken;
+  while (true) {
+    var token = this._lang_next();
+    tokens.add(token);
+    var kind = token.kind;
+    if (kind == 2/*TokenKind.LPAREN*/) {
+      positions.add(token.start);
+    }
+    else if (kind == 3/*TokenKind.RPAREN*/) {
+      var openPos = positions.removeLast();
+      if (positions.length == 0) break;
+      this._afterCloseParenCache.$setindex(openPos, this._peekToken);
+      if (openPos > this._highestCachePosition) this._highestCachePosition = openPos;
+    }
+    else if (kind == 1/*TokenKind.END_OF_FILE*/) {
+      this._lang_error('parenthesis never closed', firstOpenParen.get$span());
+      this._afterCloseParenCache = new HashMapImplementation$int$Token();
+      this._highestCachePosition = -1;
+      break;
+    }
+  }
+  var after = this._peekToken;
+  tokens.add(this._peekToken);
+  this.tokenizer = new DivertedTokenSource(tokens, this, this.tokenizer);
+  this._lang_next();
+  return after;
+}
 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 345 matching lines @@
   }
   return formals;
 }
 lang_Parser.prototype.identifier = function() {
   var tok = this._lang_next();
   if (!TokenKind.isIdentifier(tok.kind)) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
   return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
-lang_Parser.prototype._makeFunction = function(expr, body) {
+lang_Parser.prototype._makeFunction = function(expr, formals, body) {
   var name, type;
-  if ((expr instanceof CallExpression)) {
-    if ((expr.target instanceof VarExpression)) {
-      name = expr.target.get$name();
-      type = null;
-    }
-    else if ((expr.target instanceof DeclaredIdentifier)) {
-      name = expr.target.get$name();
-      type = expr.target.type;
-    }
-    else {
-      this._lang_error('bad function');
-    }
-    var formals = this._makeFormals(expr.get$arguments());
-    var span = new SourceSpan(expr.get$span().file, expr.get$span().start, body.get$span().end);
-    var func = new FunctionDefinition(null, type, name, formals, null, body, span);
-    return new LambdaExpression(func, func.get$span());
+  if ((expr instanceof VarExpression)) {
+    name = expr.get$name();
+    type = null;
+  }
+  else if ((expr instanceof DeclaredIdentifier)) {
+    name = expr.get$name();
+    type = expr.type;
   }
   else {
-    this._lang_error('expected function');
+    this._lang_error('bad function');
   }
-}
-lang_Parser.prototype._makeFormal = function(expr) {
-  if ((expr instanceof VarExpression)) {
-    return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
-  }
-  else if ((expr instanceof DeclaredIdentifier)) {
-    return new FormalNode(false, false, expr.type, expr.get$name(), null, expr.get$span());
-  }
-  else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier))) {
-    var di = expr.x;
-    return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
-  }
-  else if (this._isBin(expr, 52/*TokenKind.LT*/)) {
-    return null;
-  }
-  else if ((expr instanceof ListExpression)) {
-    return this._makeFormalsFromList(expr);
-  }
-  else {
-    this._lang_error('expected formal', expr.get$span());
-  }
-}
-lang_Parser.prototype._makeFormalsFromList = function(expr) {
-  if (expr.get$isConst()) {
-    this._lang_error('expected formal, but found "const"', expr.get$span());
-  }
-  else if ($ne(expr.type, null)) {
-    this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
-  }
-  return this._makeFormalsFromExpressions(expr.values, false);
-}
-lang_Parser.prototype._makeFormals = function(arguments) {
-  var expressions = [];
-  for (var i = 0;
-   i < arguments.length; i++) {
-    var arg = arguments.$index(i);
-    if (arg.label != null) {
-      this._lang_error('expected formal, but found ":"');
-    }
-    expressions.add(arg.get$value());
-  }
-  return this._makeFormalsFromExpressions(expressions, true);
-}
-lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
-  var formals = [];
-  for (var i = 0;
-   i < expressions.length; i++) {
-    var formal = this._makeFormal(expressions.$index(i));
-    if (formal == null) {
-      var baseType = this._makeType(expressions.$index(i).x);
-      var typeParams = [this._makeType(expressions.$index(i).y)];
-      i++;
-      while (i < expressions.length) {
-        var expr = expressions.$index(i++);
-        if (this._isBin(expr, 53/*TokenKind.GT*/)) {
-          typeParams.add(this._makeType(expr.x));
-          var type = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan(baseType.get$span().start));
-          var name = null;
-          if ((expr.y instanceof VarExpression)) {
-            var ve = expr.y;
-            name = ve.name;
-          }
-          else {
-            this._lang_error('expected formal', expr.get$span());
-          }
-          formal = new FormalNode(false, false, type, name, null, this._makeSpan(expressions.$index(0).get$span().start));
-          break;
-        }
-        else {
-          typeParams.add(this._makeType(expr));
-        }
-      }
-      formals.add(formal);
-    }
-    else if (!!(formal && formal.is$List)) {
-      formals.addAll(formal);
-      if (!allowOptional) {
-        this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
-      }
-    }
-    else {
-      formals.add(formal);
-    }
-  }
-  return formals;
+  var span = new SourceSpan(expr.get$span().file, expr.get$span().start, body.get$span().end);
+  var func = new FunctionDefinition(null, type, name, formals, null, body, span);
+  return new LambdaExpression(func, func.get$span());
 }
 lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
     this._lang_error('expected declared identifier');
     return new DeclaredIdentifier(null, null, e.get$span());
   }
 }
 lang_Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
+// ********** 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;
+}
 // ********** Code for lang_Node **************
 function lang_Node(span) {
   this.span = span;
   // Initializers done
 }
 lang_Node.prototype.get$span = function() { return this.span; };
 lang_Node.prototype.set$span = function(value) { return this.span = value; };
 // ********** Code for Definition **************
 function Definition(span) {
   lang_Statement.call(this, span);
@@ skipping 92 matching lines @@
 // ********** Code for DirectiveDefinition **************
 function DirectiveDefinition(name, arguments, span) {
   this.name = name;
   this.arguments = arguments;
   Definition.call(this, span);
   // Initializers done
 }
 $inherits(DirectiveDefinition, Definition);
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
-DirectiveDefinition.prototype.get$arguments = function() { return this.arguments; };
-DirectiveDefinition.prototype.set$arguments = function(value) { return this.arguments = value; };
 DirectiveDefinition.prototype.visit = function(visitor) {
   return visitor.visitDirectiveDefinition(this);
 }
 // ********** Code for TypeDefinition **************
 function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, factoryType, body, span) {
   this.isClass = isClass;
   this.name = name;
   this.typeParameters = typeParameters;
   this.extendsTypes = extendsTypes;
   this.implementsTypes = implementsTypes;
@@ skipping 266 matching lines @@
   return visitor.visitLambdaExpression(this);
 }
 // ********** Code for CallExpression **************
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(CallExpression, lang_Expression);
-CallExpression.prototype.get$arguments = function() { return this.arguments; };
-CallExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 // ********** Code for IndexExpression **************
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
   lang_Expression.call(this, span);
   // Initializers done
 }
@@ skipping 42 matching lines @@
   this.name = name;
   this.arguments = arguments;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(lang_NewExpression, lang_Expression);
 lang_NewExpression.prototype.get$isConst = function() { return this.isConst; };
 lang_NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
 lang_NewExpression.prototype.get$name = function() { return this.name; };
 lang_NewExpression.prototype.set$name = function(value) { return this.name = value; };
-lang_NewExpression.prototype.get$arguments = function() { return this.arguments; };
-lang_NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 lang_NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 // ********** Code for ListExpression **************
 function ListExpression(isConst, type, values, span) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
   lang_Expression.call(this, span);
   // Initializers done
@@ skipping 2391 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();