Flatten the AST for try/catch.

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1079 matching lines @@
                                                          field,
                                                          expr);
   current_block_->statements->Add(store);
   SequenceNode* try_block = CloseBlock();  // End try block.
 
   OpenBlock();  // Start catch handler list.
   SourceLabel* end_catch_label =
       SourceLabel::New(token_pos, NULL, SourceLabel::kCatch);
   current_block_->scope->AddLabel(end_catch_label);
 
   OpenBlock();  // Start catch clause.

[Florian Schneider, 2013/11/05 10:05:30]

The same should be done here for try-catch generated here.

   AstNode* compare_transition_sentinel = new ComparisonNode(
       token_pos,
       Token::kEQ_STRICT,
       new LoadStaticFieldNode(token_pos, field),
       new LiteralNode(field.token_pos(), Object::transition_sentinel()));
 
   SequenceNode* store_null = new SequenceNode(token_pos, NULL);
   store_null->Add(new StoreStaticFieldNode(
       field.token_pos(),
       field,
@@ skipping 5724 matching lines @@
 
   // Now parse the 'try' block.
   OpenBlock();
   Block* current_try_block = current_block_;
   PushTryBlock(current_try_block);
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* try_block = CloseBlock();
 
+  if ((CurrentToken() != Token::kCATCH) && !IsLiteral("on") &&
+      (CurrentToken() != Token::kFINALLY)) {
+    ErrorMsg("catch or finally clause expected");
+  }
+
   // Now create a label for the end of catch block processing so that we can
   // jump over the catch block code after executing the try block.
   SourceLabel* end_catch_label =
       SourceLabel::New(TokenPos(), NULL, SourceLabel::kCatch);
 
   // Now parse the 'catch' blocks if any and merge all of them into
   // an if-then sequence of the different types specified using the 'is'
   // operator.
-  bool catch_seen = false;
   bool generic_catch_seen = false;
   const intptr_t handler_pos = TokenPos();
   OpenBlock();  // Start the catch block sequence.
   current_block_->scope->AddLabel(end_catch_label);
   const GrowableObjectArray& handler_types =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   bool needs_stacktrace = false;
   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::kCanonicalize));
     } else {
       exception_param.type =
           &AbstractType::ZoneHandle(Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
       exception_param.var = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
         // 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");
       }
       ExpectToken(Token::kRPAREN);
     }
 
+    // Parse the individual catch handler code and add an unconditional
+    // JUMP to the end of the try block.
+    ExpectToken(Token::kLBRACE);
     OpenBlock();
     AddCatchParamsToScope(exception_param,
                           stack_trace_param,
                           current_block_->scope);
 
-    // Parse the individual catch handler code and add an unconditional
-    // JUMP to the end of the try block.
-    ExpectToken(Token::kLBRACE);
-    OpenBlock();
-
     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)));
     }
@@ skipping 53 matching lines @@
     } 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;
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
       handler_types.Add(*exception_param.type);
     }
-    SequenceNode* catch_clause = CloseBlock();
-
-    // Add this individual catch handler to the catch handlers list.
-    current_block_->statements->Add(catch_clause);
   }
   SequenceNode* catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
   const intptr_t try_index = inner_try_block->try_index();
   TryBlocks* outer_try_block = try_blocks_list_;
   const intptr_t outer_try_index = (outer_try_block != NULL)
       ? outer_try_block->try_index()
       : CatchClauseNode::kInvalidTryIndex;
 
   // Finally parse the 'finally' block.
@@ skipping 11 matching lines @@
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
                                                         context_var,
                                                         outer_try_index);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock();
-  } else {
-    if (!catch_seen) {
-      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 3757 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart