Add support for rethrow and start treating throw <expr> as an expression.

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

Index: sdk/lib/_internal/compiler/implementation/scanner/parser.dart
diff --git a/sdk/lib/_internal/compiler/implementation/scanner/parser.dart b/sdk/lib/_internal/compiler/implementation/scanner/parser.dart
index c2469c35e487892541b29c5390a7c37da93f9b34..2c6c862dc5ae3c3560c3f5721f4d6af4ec66b241 100644
--- a/sdk/lib/_internal/compiler/implementation/scanner/parser.dart
+++ b/sdk/lib/_internal/compiler/implementation/scanner/parser.dart
@@ -1197,8 +1197,11 @@ class Parser {
       return parseIfStatement(token);
     } else if (identical(value, 'for')) {
       return parseForStatement(token);
-    } else if (identical(value, 'throw')) {
-      return parseThrowStatement(token);
+    } else if (identical(value, 'rethrow')) {
+      return parseRethrowStatement(token);
+    } else if (identical(value, 'throw') && optional(';', token.next)) {
+      // TODO(kasperl): Stop dealing with throw here.
+      return parseRethrowStatement(token);

[ahe, 2013/04/23 09:37:25]

I think this should report a deprecated feature. IIRC, the listener has a method
for that. 

[kasperl, 2013/04/23 11:26:12]

Done in the listener.

     } else if (identical(value, 'void')) {
       return parseExpressionStatementOrDeclaration(token);
     } else if (identical(value, 'while')) {
@@ -1351,11 +1354,19 @@ class Parser {
   }
 
   Token parseExpression(Token token) {
-    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, true);
+    if (optional('throw', token)) {
+      return parseThrowExpression(token, true);

[ahe, 2013/04/23 09:37:25]

I don't think this will handle situations like "1 + throw foo". You need to
incorporate this in parsePrecedenceExpression and determine the "precedence" of
throw as a prefix unary operator.

Also, by not using precedence info, you're probably making parsing of
expressions slower. 

[kasperl, 2013/04/23 11:26:12]

I think that is true, but the grammar in the specification doesn't seem to allow
'1 + throw 1' since throw isn't a multiplicative expression. I agree that the
grammar is a bit messed up, but what I've implemented here seems to match it and
the VM behavior. I'm all for changing that of course.

+    } else {
+      return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, true);
+    }
   }
 
   Token parseExpressionWithoutCascade(Token token) {
-    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, false);
+    if (optional('throw', token)) {
+      return parseThrowExpression(token, false);
+    } else {
+      return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, false);
+    }
   }
 
   Token parseConditionalExpressionRest(Token token) {
@@ -2035,18 +2046,28 @@ class Parser {
     return expect('}', token);
   }
 
-  Token parseThrowStatement(Token token) {
+  Token parseThrowExpression(Token token, bool allowCascades) {
     Token throwToken = token;
-    listener.beginThrowStatement(throwToken);
+    listener.beginThrowExpression(throwToken);
     token = expect('throw', token);
-    if (optional(';', token)) {
-      listener.endRethrowStatement(throwToken, token);
-      return token.next;
+    token = allowCascades
+        ? parseExpression(token)
+        : parseExpressionWithoutCascade(token);
+    listener.endThrowExpression(throwToken, token);
+    return token;
+  }
+
+  Token parseRethrowStatement(Token token) {
+    Token throwToken = token;
+    listener.beginRethrowStatement(throwToken);
+    // TODO(kasperl): Disallow throw here.
+    if (identical(throwToken.stringValue, 'throw')) {
+      token = expect('throw', token);
     } else {
-      token = parseExpression(token);
-      listener.endThrowStatement(throwToken, token);
-      return expectSemicolon(token);
+      token = expect('rethrow', token);
     }
+    listener.endRethrowStatement(throwToken, token);
+    return expectSemicolon(token);
   }
 
   Token parseTryStatement(Token token) {