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

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 1179 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, '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')) {
       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 132 matching lines @@
   }
 
   Token parseExpressionStatement(Token token) {
     listener.beginExpressionStatement(token);
     token = parseExpression(token);
     listener.endExpressionStatement(token);
     return expectSemicolon(token);
   }
 
   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) {
     assert(optional('?', token));
     Token question = token;
     token = parseExpressionWithoutCascade(token.next);
     Token colon = token;
     token = expect(':', token);
     token = parseExpressionWithoutCascade(token);
     listener.handleConditionalExpression(question, colon);
@@ skipping 659 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 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) {
     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);
   }
 }