Add catchless catch clauses

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 5829 matching lines @@
                     condition,
                     NodeAsSequenceNode(condition_pos, assert_throw, NULL),
                     NULL);
 }
 
 
 // TODO(hausner): This structure can be simplified once the old catch
 // syntax is removed. All catch parameters in the new syntax are final.
 struct CatchParamDesc {
   CatchParamDesc()
-      : token_pos(0), type(NULL), var(NULL), is_final(false) { }
+      : token_pos(0), type(NULL), var(NULL) { }
   intptr_t token_pos;
   const AbstractType* type;
   const String* var;
-  bool is_final;
 };
 
 
-// Parse the parameter specified in the catch clause.
-void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
-  TRACE_PARSER("ParseCatchParameter");
-  ASSERT(catch_param != NULL);
-  catch_param->is_final = (CurrentToken() == Token::kFINAL);
-  // The type of the catch parameter must always be resolved, even in unchecked
-  // mode.
-  if (CurrentToken() == Token::kCONST) {
-    ErrorMsg("Catch parameter cannot be 'const'");
-  }
-  catch_param->type = &AbstractType::ZoneHandle(
-      ParseConstFinalVarOrType(ClassFinalizer::kCanonicalizeWellFormed));
-  catch_param->token_pos = TokenPos();
-  catch_param->var = ExpectIdentifier("identifier expected");
-}
-
-
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
-  ASSERT(exception_param.var != NULL);
-  LocalVariable* var = new LocalVariable(exception_param.token_pos,
-                                         *exception_param.var,
-                                         *exception_param.type);
-  if (exception_param.is_final) {
+  if (exception_param.var != NULL) {
+    LocalVariable* var = new LocalVariable(exception_param.token_pos,
+                                           *exception_param.var,
+                                           *exception_param.type);
     var->set_is_final();
+    bool added_to_scope = scope->AddVariable(var);
+    ASSERT(added_to_scope);
   }
-  bool added_to_scope = scope->AddVariable(var);
-  ASSERT(added_to_scope);
   if (stack_trace_param.var != NULL) {
-    var = new LocalVariable(TokenPos(),
-                            *stack_trace_param.var,
-                            *stack_trace_param.type);
-    if (stack_trace_param.is_final) {
-      var->set_is_final();
-    }
-    added_to_scope = scope->AddVariable(var);
+    LocalVariable* var = new LocalVariable(TokenPos(),
+                                           *stack_trace_param.var,
+                                           *stack_trace_param.type);
+    var->set_is_final();
+    bool added_to_scope = scope->AddVariable(var);
     if (!added_to_scope) {
       ErrorMsg(stack_trace_param.token_pos,
                "name '%s' already exists in scope",
                stack_trace_param.var->ToCString());
     }
   }
 }
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
@@ skipping 136 matching lines @@
   bool generic_catch_seen = false;
   SequenceNode* catch_handler_list = NULL;
   const intptr_t handler_pos = TokenPos();
   OpenBlock();  // Start the catch block sequence.
   current_block_->scope->AddLabel(end_catch_label);
   while ((CurrentToken() == Token::kCATCH) || IsLiteral("on")) {
     const intptr_t catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     catch_seen = true;
+    if (IsLiteral("on")) {
+      ConsumeToken();
+      exception_param.type = &AbstractType::ZoneHandle(
+          ParseType(ClassFinalizer::kCanonicalizeWellFormed));
+    } else {
+      exception_param.type =
+          &AbstractType::ZoneHandle(Type::DynamicType());
+    }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
-      if (IsIdentifier() &&
-          ((LookaheadToken(1) == Token::kCOMMA) ||
-          (LookaheadToken(1) == Token::kRPAREN))) {
-        // New catch syntax for untyped exception variable:
-        // catch(e) or catch (e,s).
-        exception_param.is_final = true;
-        exception_param.type =
-            &AbstractType::ZoneHandle(Type::DynamicType());
-        exception_param.token_pos = TokenPos();
-        exception_param.var = ExpectIdentifier("identifier expected");
-        if (CurrentToken() == Token::kCOMMA) {
-          ConsumeToken();
-          stack_trace_param.is_final = true;
-          // TODO(hausner): Make implicit type be StackTrace, not Dynamic.
-          stack_trace_param.type =
-              &AbstractType::ZoneHandle(Type::DynamicType());
-          stack_trace_param.token_pos = TokenPos();
-          stack_trace_param.var = ExpectIdentifier("identifier expected");
-        }
-      } else {
-        // TODO(hausner): Improve error message and maybe also the
-        // structure of the code. Maybe you can get away with simply
-        // expecting an identifier followed by a comma or a right
-        // parenthesis?
-        ErrorMsg("identifier expected here, not type, final, or var");
-      }
-    } else {
-      // on T catch(e) { ...
-      ConsumeToken();  // on
-      exception_param.is_final = true;
-      exception_param.type = &AbstractType::ZoneHandle(
-          ParseType(ClassFinalizer::kCanonicalizeWellFormed));
-      ExpectToken(Token::kCATCH);
-      ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
       exception_param.var = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
-        stack_trace_param.is_final = true;
-        // TODO(hausner): Make imlicit type be StackTrace, not Dynamic.
+        // TODO(hausner): Make implicit type be StackTrace, not Dynamic.
         stack_trace_param.type =
-        &AbstractType::ZoneHandle(Type::DynamicType());
+            &AbstractType::ZoneHandle(Type::DynamicType());
         stack_trace_param.token_pos = TokenPos();
         stack_trace_param.var = ExpectIdentifier("identifier expected");
       }
+      ExpectToken(Token::kRPAREN);
     }
-    ExpectToken(Token::kRPAREN);
 
     // If a generic "catch all" statement has already been seen then all
     // subsequent catch statements are dead. We issue an error for now,
     // it might make sense to turn this into a warning.
     if (generic_catch_seen) {
       ErrorMsg("a generic 'catch all' statement already exists for this "
                "try block. All subsequent catch statements are dead code");
     }
     OpenBlock();
     AddCatchParamsToScope(exception_param,
                           stack_trace_param,
                           current_block_->scope);
 
-    SequenceNode* catch_clause;
-
     // Parse the individual catch handler code and add an unconditional
     // JUMP to the end of the try block.
     ExpectToken(Token::kLBRACE);
     OpenBlock();
 
-    // Generate code to load the exception object (:exception_var) into
-    // the exception variable specified in this block.
-    ASSERT(exception_param.var != NULL);
-    LocalVariable* var = LookupLocalScope(*exception_param.var);
-    ASSERT(var != NULL);
-    ASSERT(catch_excp_var != NULL);
-    current_block_->statements->Add(
-        new StoreLocalNode(catch_pos,
-                           var,
-                           new LoadLocalNode(catch_pos, catch_excp_var)));
+    if (exception_param.var != NULL) {
+      // Generate code to load the exception object (:exception_var) into
+      // the exception variable specified in this block.
+      LocalVariable* var = LookupLocalScope(*exception_param.var);
+      ASSERT(var != NULL);
+      ASSERT(catch_excp_var != NULL);
+      current_block_->statements->Add(
+          new StoreLocalNode(catch_pos, var,
+                             new LoadLocalNode(catch_pos, catch_excp_var)));
+    }
     if (stack_trace_param.var != NULL) {
       // A stack trace variable is specified in this block, so generate code
       // to load the stack trace object (:stacktrace_var) into the stack trace
       // variable specified in this block.
       LocalVariable* trace = LookupLocalScope(*stack_trace_param.var);
       ASSERT(catch_trace_var != NULL);
       current_block_->statements->Add(
-          new StoreLocalNode(catch_pos,
-                             trace,
+          new StoreLocalNode(catch_pos, trace,
                              new LoadLocalNode(catch_pos, catch_trace_var)));
     }
 
     ParseStatementSequence();  // Parse the catch handler code.
     current_block_->statements->Add(
         new JumpNode(catch_pos, Token::kCONTINUE, end_catch_label));
     SequenceNode* catch_handler = CloseBlock();
     ExpectToken(Token::kRBRACE);
 
     if (!exception_param.type->IsDynamicType()) {  // Has a type specification.
@@ skipping 12 matching lines @@
       AstNode* type_cond_expr = new ComparisonNode(
           catch_pos, Token::kIS, exception_var, exception_type);
       current_block_->statements->Add(
           new IfNode(catch_pos, type_cond_expr, catch_handler, NULL));
     } else {
       // No exception type exists in the catch specifier so execute the
       // catch handler code unconditionally.
       current_block_->statements->Add(catch_handler);
       generic_catch_seen = true;
     }
-    catch_clause = CloseBlock();
+    SequenceNode* catch_clause = CloseBlock();
 
     // Add this individual catch handler to the catch handlers list.
     current_block_->statements->Add(catch_clause);
   }
   catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
 
   // Finally parse the 'finally' block.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
@@ skipping 18 matching lines @@
     if (!generic_catch_seen) {
       // No generic catch handler exists so execute this finally block
       // before rethrowing the exception.
       finally_block = ParseFinallyBlock();
       catch_handler_list->Add(finally_block);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock();
   } else {
     if (!catch_seen) {
-      ErrorMsg("'catch' or 'finally' expected");
+      ErrorMsg("catch or finally clause expected");
     }
   }
 
   if (!generic_catch_seen) {
     // No generic catch handler exists so rethrow the exception so that
     // the next catch handler can deal with it.
     catch_handler_list->Add(
         new ThrowNode(handler_pos,
                       new LoadLocalNode(handler_pos, catch_excp_var),
                       new LoadLocalNode(handler_pos, catch_trace_var)));
@@ skipping 3523 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart