Fix for Issue 622

frog/parser.dart

 // 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): Error recovery needs major work!
 /**
  * A simple recursive descent parser for the dart language.
  *
  * This parser is designed to be more permissive than the official
  * Dart grammar.  It is expected that many grammar errors would be
@@ skipping 16 matching lines @@
   /** Allow semicolons to be omitted at the end of lines. */
   // TODO(nweiz): make this work for more than just end-of-file
   final bool optionalSemicolons;
 
   /**
    * Allow the await keyword, when the await transformation is available (see
    * await/awaitc.dart).
    */
   bool get enableAwait() => experimentalAwaitPhase != null;
 
-  /** To prevent conflicts in initializers */
-  bool _inInitializers;
+  /**
+   * To resolve ambiguity in initializers between constructor body and lambda
+   * expression.
+   */
+  bool _inhibitLambda;
 
   Token _previousToken;
   Token _peekToken;
 
   // When we encounter '(' in a method body we need to find the ')' to know it
   // we're parsing a lambda, paren-expr, or argument list. Closure formals are
   // followed by '=>' or '{'. This list is used to cache the tokens after any
   // nested parenthesis we find while peeking.
   // TODO(jmesserly): it's simpler and faster to cache this on the Token itself,
   // but that might add too much complexity for tools that need to invalidate.
   List<Token> _afterParens;
   int _afterParensIndex = 0;
 
   Parser(this.source, [this.diet = false, this.throwOnIncomplete = false,
       this.optionalSemicolons = false, int startOffset = 0]) {
     tokenizer = new Tokenizer(source, true, startOffset);
     _peekToken = tokenizer.next();
     _previousToken = null;
-    _inInitializers = false;
+    _inhibitLambda = false;
     _afterParens = <Token>[];
   }
 
   /** Generate an error if [source] has not been completely consumed. */
   void checkEndOfFile() {
     _eat(TokenKind.END_OF_FILE);
   }
 
   /** Guard to break out of parser when an unexpected end of file is found. */
   // TODO(jimhug): Failure to call this method can lead to inifinite parser
@@ skipping 209 matching lines @@
     var formals = formalParameterList();
     _eatSemicolon();
 
     var func = new FunctionDefinition(null, di.type, di.name, formals,
         null, null, null, null, _makeSpan(start));
 
     return new FunctionTypeDefinition(func, typeParams, _makeSpan(start));
   }
 
   initializers() {
-    _inInitializers = true;
+    _inhibitLambda = true;
     var ret = [];
     do {
       ret.add(expression());
     } while (_maybeEat(TokenKind.COMMA));
-    _inInitializers = false;
+    _inhibitLambda = false;
     return ret;
   }
 
   functionBody(bool inExpression) {
     int start = _peekToken.start;
     if (_maybeEat(TokenKind.ARROW)) {
       var expr = expression();
       if (!inExpression) {
         _eatSemicolon();
       }
@@ skipping 619 matching lines @@
     if (label === null && _maybeEat(TokenKind.COLON)) {
       label = _makeLabel(expr);
       expr = expression();
     }
     return new ArgumentNode(label, expr, _makeSpan(start));
   }
 
   arguments() {
     var args = [];
     _eatLeftParen();
+    var saved = _inhibitLambda;
+    _inhibitLambda = false;
     if (!_maybeEat(TokenKind.RPAREN)) {
       do {
         args.add(argument());
       } while (_maybeEat(TokenKind.COMMA));
       _eat(TokenKind.RPAREN);
     }
+     _inhibitLambda = saved;
     return args;
   }
 
   finishPostfixExpression(expr) {
     switch(_peek()) {
       case TokenKind.LPAREN:
         return finishCallOrLambdaExpression(expr);
       case TokenKind.LBRACK:
         _eat(TokenKind.LBRACK);
         var index = expression();
@@ skipping 224 matching lines @@
 
   _parenOrLambda() {
     int start = _peekToken.start;
     if (_atClosureParameters()) {
       var formals = formalParameterList();
       var body = functionBody(true);
       var func = new FunctionDefinition(null, null, null, formals, null, null,
         null, body, _makeSpan(start));
       return new LambdaExpression(func, func.span);
     } else {
-      var saved = _inInitializers;
-      _inInitializers = false;
-      var args = arguments();
-      _inInitializers = saved;
-      if (args.length == 1) {
-        return new ParenExpression(args[0].value, _makeSpan(start));
-      } else {
-        _error('unexpected comma expression');
-        return args[0].value;
-      }
+      _eatLeftParen();
+      var saved = _inhibitLambda;
+      _inhibitLambda = false;
+      var expr = expression();
+      _eat(TokenKind.RPAREN);
+      _inhibitLambda = saved;
+      return new ParenExpression(expr, _makeSpan(start));
     }
   }
 
   bool _atClosureParameters() {
-    if (_inInitializers) return false;
+    if (_inhibitLambda) return false;
     Token after = _peekAfterCloseParen();
     return after.kind == TokenKind.ARROW || after.kind == TokenKind.LBRACE;
   }
 
   /** Eats an LPAREN, and advances our after-RPAREN lookahead. */
   _eatLeftParen() {
     _eat(TokenKind.LPAREN);
     _afterParensIndex++;
   }
 
@@ skipping 493 matching lines @@
   int _pos = 0;
   next() {
     var token = tokens[_pos];
     ++_pos;
     if (_pos == tokens.length) {
       parser.tokenizer = previousTokenizer;
     }
     return token;
   }
 }