Parse all variations of for-statement.

dart/frog/leg/scanner/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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list.
  */
 class Parser {
   final Listener listener;
@@ skipping 1028 matching lines @@
       }
       token = parseExpression(token.next);
       if (colon !== null) listener.handleNamedArgument(colon);
       ++argumentCount;
     } while (optional(',', token));
     listener.endArguments(argumentCount, begin, token);
     return expect(')', token);
   }
 
   Token parseVariablesDeclaration(Token token) {
+    token = parseVariablesDeclarationNoSemicolon(token);
+    return expectSemicolon(token);
+  }
+
+  Token parseVariablesDeclarationNoSemicolon(Token token) {
     int count = 1;
     listener.beginVariablesDeclaration(token);
     token = parseFinalVarOrType(token);
     token = parseOptionallyInitializedIdentifier(token);
     while (optional(',', token)) {
       token = parseOptionallyInitializedIdentifier(token.next);
       ++count;
     }
     listener.endVariablesDeclaration(count, token);
-    return expectSemicolon(token);
+    return token;
   }
 
   Token parseOptionallyInitializedIdentifier(Token token) {
     listener.beginInitializedIdentifier(token);
     token = parseIdentifier(token);
     if (optional('=', token)) {
       Token assignment = token;
       listener.beginInitializer(token);
       token = parseExpression(token.next);
       listener.endInitializer(assignment);
@@ skipping 30 matching lines @@
     Token elseToken = null;
     if (optional('else', token)) {
       elseToken = token;
       token = parseStatement(token.next);
     }
     listener.endIfStatement(ifToken, elseToken);
     return token;
   }
 
   Token parseForStatement(Token token) {
-    // TODO(ahe): Support for-in.
     Token forToken = token;
     listener.beginForStatement(forToken);
     token = expect('for', token);
     token = expect('(', token);
-    token = parseVariablesDeclaration(token); // TODO(ahe): Support other forms.
-    token = parseExpressionStatement(token);
-    token = parseExpression(token); // TODO(ahe): Support expression list here.
+    token = parseVariablesDeclarationOrExpressionOpt(token);
+    if (optional('in', token)) {
+      return parseForInRest(forToken, token);
+    } else {
+      return parseForRest(forToken, token);
+    }
+  }
+
+  Token parseVariablesDeclarationOrExpressionOpt(Token token) {
+    final String value = token.stringValue;
+    if (value === ';') {
+      listener.handleNoExpression(token);
+      return token;
+    } else if ((value === 'var') || (value === 'final')) {
+      return parseVariablesDeclarationNoSemicolon(token);
+    }
+    Token identifier = peekIdentifierAfterType(token);
+    if (identifier !== null) {
+      assert(identifier.kind === IDENTIFIER_TOKEN);
+      Token afterId = identifier.next;
+      int afterIdKind = afterId.kind;
+      if (afterIdKind === EQ_TOKEN || afterIdKind === SEMICOLON_TOKEN ||
+          afterIdKind === COMMA_TOKEN || optional('in', afterId)) {
+        return parseVariablesDeclarationNoSemicolon(token);
+      }
+    }
+    return parseExpression(token);
+  }
+
+  Token parseForRest(Token forToken, Token token) {
+    token = expectSemicolon(token);
+    if (optional(';', token)) {
+      token = parseEmptyStatement(token);
+    } else {
+      token = parseExpressionStatement(token);
+    }
+    int expressionCount = 0;
+    if (optional(')', token)) {
+      listener.endForStatement(expressionCount, forToken, token.next);
+      return token.next;
+    }
+    token = parseExpression(token);
+    ++expressionCount;
+    while (optional(',', token)) {
+      token = parseExpression(token.next);
+      ++expressionCount;
+    }
     token = expect(')', token);
     token = parseStatement(token);
-    listener.endForStatement(forToken, token);
+    listener.endForStatement(expressionCount, forToken, token);
     return token;
   }
 
+  Token parseForInRest(Token forToken, Token token) {
+    assert(optional('in', token));
+    Token inKeyword = token;
+    token = parseExpression(token.next);
+    token = expect(')', token);
+    token = parseStatement(token);
+    listener.endForInStatement(forToken, inKeyword, token);
+    return token;
+  }
+
   Token parseWhileStatement(Token token) {
     Token whileToken = token;
     listener.beginWhileStatement(whileToken);
     token = expect('while', token);
     token = parseParenthesizedExpression(token);
     token = parseStatement(token);
     listener.endWhileStatement(whileToken, token);
     return token;
   }
 
@@ skipping 99 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }