https://code.google.com/p/dart/issues/detail?id=255

compiler/java/com/google/dart/compiler/parser/DartParser.java

 // 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.
 
 package com.google.dart.compiler.parser;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.io.CharStreams;
 import com.google.dart.compiler.DartCompilationError;
 import com.google.dart.compiler.DartCompilerListener;
@@ skipping 1005 matching lines @@
       DartFieldDefinition fieldDefinition =
         new DartFieldDefinition(null, Lists.<DartField>create(field));
       fieldDefinition.setSourceInfo(field);
       return fieldDefinition;
     }
     return method;
   }
 
   /**
    * <pre>
+   * initializers
+   *            : ':' superCallOrFirstFieldInitializer (',' fieldInitializer)*
+   *            | THIS ('.' identifier) formalParameterList
+   *            ;
+   *
    * fieldInitializer
-   *     : (THIS '.')? identifier '=' conditionalExpression
-   *     | THIS ('.' identifier)? arguments
-   *     ;
+   *            : (THIS '.')? identifier '=' conditionalExpression
+   *            ;
+   *
+   * superCallOrFirstFieldInitializer
+   *            : SUPER arguments | SUPER '.' identifier arguments
+   *            | fieldInitializer
+   *            ;
+   *
+   * fieldInitializer
+   *            : (THIS '.')? identifier '=' conditionalExpression
+   *            | THIS ('.' identifier)? arguments
+   *            ;
    * </pre>
-   *
    * @return true if initializer is a redirected constructor, false otherwise.
    */
-  private boolean parseFieldInitializersOrRedirectedConstructor(List<DartInitializer> inits) {
+  private boolean parseInitializers(List<DartInitializer> initializers) {
+    expect(Token.COLON);
     do {
-      beginFieldInitializerOrRedirectedConstructor();
-      boolean hasThisPrefix = optional(Token.THIS);
-      if (hasThisPrefix) {
-        if (match(Token.LPAREN)) {
-          return parseRedirectedConstructorInvocation(null, inits);
+      beginInitializer();
+      if (match(Token.SUPER)) {
+        beginSuperInitializer();
+        expect(Token.SUPER);
+        DartIdentifier constructor = null;
+        if (optional(Token.PERIOD)) {
+          constructor = parseIdentifier();
         }
-        expect(Token.PERIOD);
-      }
-      DartIdentifier name = parseIdentifier();
-      if (hasThisPrefix && match(Token.LPAREN)) {
-        return parseRedirectedConstructorInvocation(name, inits);
+        DartSuperConstructorInvocation superInvocation =
+          new DartSuperConstructorInvocation(constructor, parseArguments());
+        initializers.add(done(new DartInitializer(null, done(superInvocation))));
       } else {
-        expect(Token.ASSIGN);
-        boolean save = setAllowFunctionExpression(false);
-        DartExpression initExpr = parseExpression();
-        setAllowFunctionExpression(save);
-        inits.add(done(new DartInitializer(name, initExpr)));
+        boolean hasThisPrefix = optional(Token.THIS);
+        if (hasThisPrefix) {
+          if (match(Token.LPAREN)) {
+            return parseRedirectedConstructorInvocation(null, initializers);

[mmendez, 2011/11/08 15:24:06]

Nit: this follows the existing pattern, but it would be better to try and parser
all of the initializer expressions and then add a check later for redirect
constructors etc.

As it is if there are initializer expressions we give a pretty cryptic error
message about unexpected tokens.

[fabiomfv, 2011/11/08 15:34:55]

+1. we need proper error recovery. 

+          }
+          expect(Token.PERIOD);
+        }
+        DartIdentifier name = parseIdentifier();
+        if (hasThisPrefix && match(Token.LPAREN)) {
+          return parseRedirectedConstructorInvocation(name, initializers);
+        } else {
+          expect(Token.ASSIGN);
+          boolean save = setAllowFunctionExpression(false);
+          DartExpression initExpr = parseExpression();
+          setAllowFunctionExpression(save);
+          initializers.add(done(new DartInitializer(name, initExpr)));
+        }
       }
     } while (optional(Token.COMMA));
     return false;
   }
 
   private boolean parseRedirectedConstructorInvocation(DartIdentifier name,
-                                                       List<DartInitializer> inits) {
-    if (inits.isEmpty()) {
-      DartInvocation call =
-        doneWithoutConsuming(new DartRedirectConstructorInvocation(name, parseArguments()));
-      inits.add(done(new DartInitializer(null, call)));
+                                                       List<DartInitializer> initializers) {
+    if (initializers.isEmpty()) {
+      DartRedirectConstructorInvocation redirConstructor =
+        new DartRedirectConstructorInvocation(name, parseArguments());
+      initializers.add(done(new DartInitializer(null, doneWithoutConsuming(redirConstructor))));
       return true;
     } else {
       reportUnexpectedToken(position(), Token.ASSIGN, Token.LPAREN);
     }
     return false;
   }
 
   /**
    * <pre>
-   * initializers : ':' superCallOrFirstFieldInitializer (',' fieldInitializer)*
-   *              | THIS ('.' identifier) formalParameterList ;
-   *
-   * fieldInitializer : (THIS '.')? identifier '=' conditionalExpression ;
-   *
-   * superCallOrFirstFieldInitializer : SUPER arguments | SUPER '.' identifier
-   * arguments | fieldInitializer ;
-   * <pre>
-   *
-   * @return true if initializer is a redirect constructor, false otherwise.
-   */
-  private boolean parseInitializers(List<DartInitializer> initializers) {
-    expect(Token.COLON);
-    boolean callSuper = false;
-    if (match(Token.SUPER)) {
-      beginInitializer();
-      beginSuperInitializer();
-      expect(Token.SUPER);
-      callSuper = true;
-      DartIdentifier constructor = null;
-      if (optional(Token.PERIOD)) {
-        // Calling a super named constructor.
-        constructor = parseIdentifier();
-      }
-      DartSuperConstructorInvocation call =
-          done(new DartSuperConstructorInvocation(constructor, parseArguments()));
-      initializers.add(done(new DartInitializer(null, call)));
-    }
-    if (!callSuper || optional(Token.COMMA)) {
-      return parseFieldInitializersOrRedirectedConstructor(initializers);
-    }
-    return false;
-  }
-
-  /**
-   * <pre>
    * variableDeclaration
    *    : constVarOrType identifierList
    *    ;
    * identifierList
    *    : identifier (',' identifier)*
    *    ;
    *
    * staticConstDeclarationList
    *    : staticConstDeclaration (',' staticConstDeclaration)*
    *    ;
@@ skipping 2358 matching lines @@
     } else {
       ctx.error(dartError);
       errorHistory.add(dartError.hashCode());
     }
   }
 
   private void reportError(DartNode node, ErrorCode errorCode, Object... arguments) {
     reportError(new DartCompilationError(node, errorCode, arguments));
   }
 }