Revive throw as an expression but not for rethrow.

sdk/lib/_internal/compiler/implementation/scanner/parser.dart

 // Copyright (c) 2012, 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.
 
 part of scanner;
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
@@ skipping 1122 matching lines @@
     } else if (identical(value, '{')) {
       return parseBlock(token);
     } else if (identical(value, 'return')) {
       return parseReturnStatement(token);
     } else if (identical(value, 'var') || identical(value, 'final')) {
       return parseVariablesDeclaration(token);
     } else if (identical(value, 'if')) {
       return parseIfStatement(token);
     } else if (identical(value, 'for')) {
       return parseForStatement(token);
-    } else if (identical(value, 'throw')) {
-      return parseThrowStatement(token);
     } else if (identical(value, 'void')) {
       return parseExpressionStatementOrDeclaration(token);
     } else if (identical(value, 'while')) {
       return parseWhileStatement(token);
     } else if (identical(value, 'do')) {
       return parseDoWhileStatement(token);
     } else if (identical(value, 'try')) {
       return parseTryStatement(token);
     } else if (identical(value, 'switch')) {
       return parseSwitchStatement(token);
@@ skipping 332 matching lines @@
       } else if (identical(value, 'this')) {
         return parseThisExpression(token);
       } else if (identical(value, 'super')) {
         return parseSuperExpression(token);
       } else if (identical(value, 'new')) {
         return parseNewExpression(token);
       } else if (identical(value, 'const')) {
         return parseConstExpression(token);
       } else if (identical(value, 'void')) {
         return parseFunctionExpression(token);
+      } else if (identical(value, 'throw')) {
+        return parseThrow(token);
       } else if (token.isIdentifier()) {
         return parseSendOrFunctionLiteral(token);
       } else {
         return listener.expectedExpression(token);
       }
     } else if (identical(kind, OPEN_PAREN_TOKEN)) {
       return parseParenthesizedExpressionOrFunctionLiteral(token);
     } else if ((identical(kind, LT_TOKEN)) ||
                (identical(kind, OPEN_SQUARE_BRACKET_TOKEN)) ||
                (identical(kind, OPEN_CURLY_BRACKET_TOKEN)) ||
@@ skipping 379 matching lines @@
       listener.handleNoExpression(token);
       return token;
     } else if ((identical(value, 'var')) || (identical(value, 'final'))) {
       return parseVariablesDeclarationNoSemicolon(token);
     }
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
       assert(identifier.isIdentifier());
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) || identical(afterIdKind, SEMICOLON_TOKEN) ||

[kasperl, 2012/12/10 14:50:05]

Long line.

           identical(afterIdKind, COMMA_TOKEN) || optional('in', afterId)) {
         return parseVariablesDeclarationNoSemicolon(token);
       }
     }
     return parseExpression(token);
   }
 
   Token parseForRest(Token forToken, Token token) {
     token = expectSemicolon(token);
     if (optional(';', token)) {
@@ skipping 56 matching lines @@
     int statementCount = 0;
     token = expect('{', token);
     while (notEofOrValue('}', token)) {
       token = parseStatement(token);
       ++statementCount;
     }
     listener.endBlock(statementCount, begin, token);
     return expect('}', token);
   }
 
-  Token parseThrowStatement(Token token) {
+  Token parseThrow(Token token) {
     Token throwToken = token;
-    listener.beginThrowStatement(throwToken);
+    listener.beginThrow(throwToken);
     token = expect('throw', token);
     if (optional(';', token)) {
-      listener.endRethrowStatement(throwToken, token);
-      return token.next;
+      listener.endRethrow(throwToken, token);

[kasperl, 2012/12/10 14:50:05]

Add a comment that it's important that you aren't consuming the ; token?

     } else {
       token = parseExpression(token);
-      listener.endThrowStatement(throwToken, token);
-      return expectSemicolon(token);
+      listener.endThrow(throwToken, token);
     }
+    return token;
   }
 
   Token parseTryStatement(Token token) {
     assert(optional('try', token));
     Token tryKeyword = token;
     listener.beginTryStatement(tryKeyword);
     token = parseBlock(token.next);
     int catchCount = 0;
 
     String value = token.stringValue;
@@ skipping 160 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }