Make throw an expression

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 6355 matching lines @@
     statement = ParseJump(label_name);
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kCONTINUE) {
     statement = ParseJump(label_name);
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Empty statement, nothing to do.
     ConsumeToken();
-  } else if (CurrentToken() == Token::kTHROW) {
+  } else if ((CurrentToken() == Token::kTHROW) &&
+             (LookaheadToken(1) == Token::kSEMICOLON)) {
+    // Rethrow of current exception. Throwing of an exception object
+    // is an expression and is handled in ParseExpr().
     ConsumeToken();
-    AstNode* expr = NULL;
-    if (CurrentToken() != Token::kSEMICOLON) {
-      expr = ParseExpr(kAllowConst, kConsumeCascades);
-      ExpectSemicolon();
-      statement = new ThrowNode(statement_pos, expr, NULL);
-    } else {  // No exception object seen so must be a rethrow.
-      // Check if it is ok to do a rethrow.
-      SourceLabel* label = current_block_->scope->LookupInnermostCatchLabel();
-      if (label == NULL ||
-          label->FunctionLevel() != current_block_->scope->function_level()) {
-        ErrorMsg("rethrow of an exception is not valid here");
-      }
-      ASSERT(label->owner() != NULL);
-      LocalScope* scope = label->owner()->parent();
-      ASSERT(scope != NULL);
-      LocalVariable* excp_var = scope->LocalLookupVariable(
-          String::ZoneHandle(Symbols::ExceptionVar()));
-      ASSERT(excp_var != NULL);
-      LocalVariable* trace_var = scope->LocalLookupVariable(
-          String::ZoneHandle(Symbols::StacktraceVar()));
-      ASSERT(trace_var != NULL);
-      statement = new ThrowNode(statement_pos,
-                                new LoadLocalNode(statement_pos, excp_var),
-                                new LoadLocalNode(statement_pos, trace_var));
+    ExpectSemicolon();
+    // Check if it is ok to do a rethrow.
+    SourceLabel* label = current_block_->scope->LookupInnermostCatchLabel();
+    if (label == NULL ||
+        label->FunctionLevel() != current_block_->scope->function_level()) {
+      ErrorMsg(statement_pos, "rethrow of an exception is not valid here");
     }
+    ASSERT(label->owner() != NULL);
+    LocalScope* scope = label->owner()->parent();
+    ASSERT(scope != NULL);
+    LocalVariable* excp_var = scope->LocalLookupVariable(
+        String::ZoneHandle(Symbols::ExceptionVar()));
+    ASSERT(excp_var != NULL);
+    LocalVariable* trace_var = scope->LocalLookupVariable(
+        String::ZoneHandle(Symbols::StacktraceVar()));
+    ASSERT(trace_var != NULL);
+    statement = new ThrowNode(statement_pos,
+                              new LoadLocalNode(statement_pos, excp_var),
+                              new LoadLocalNode(statement_pos, trace_var));
   } else {
     statement = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
 RawError* Parser::FormatErrorWithAppend(const Error& prev_error,
                                         const Script& script,
@@ skipping 587 matching lines @@
   }
   // Result of the cascade is the receiver.
   return new LoadLocalNode(cascade_pos, cascade_receiver_var);
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   const intptr_t expr_pos = TokenPos();
+
+  if (CurrentToken() == Token::kTHROW) {
+    ConsumeToken();
+    ASSERT(CurrentToken() != Token::kSEMICOLON);
+    AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
+    return new ThrowNode(expr_pos, expr, NULL);
+  }
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
       return ParseCascades(expr);
     }
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     }
     return expr;
   }
@@ skipping 2639 matching lines @@
   if (CurrentToken() == Token::kCONDITIONAL) {
     ConsumeToken();
     SkipExpr();
     ExpectToken(Token::kCOLON);
     SkipExpr();
   }
 }
 
 
 void Parser::SkipExpr() {
+  while (CurrentToken() == Token::kTHROW) {
+    ConsumeToken();
+  }
   SkipConditionalExpr();
   if (CurrentToken() == Token::kCASCADE) {
     SkipSelectors();
   }
   if (Token::IsAssignmentOperator(CurrentToken())) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart