Collect debugging info for 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 5951 matching lines @@
 
   // 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;
   SequenceNode* catch_handler_list = NULL;
   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());
   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();
       // TODO(regis): The spec may change in the way a malformed 'on' type is
       // treated. For now, we require the type to be wellformed.
       exception_param.type = &AbstractType::ZoneHandle(
@@ skipping 72 matching lines @@
       }
       TypeNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_var = new LoadLocalNode(catch_pos, catch_excp_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       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));
+      ASSERT(exception_type->type().IsInstantiated());
+      handler_types.Add(*exception_param.type);
     } 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);
   }
   catch_handler_list = CloseBlock();
   TryBlocks* inner_try_block = PopTryBlock();
 
   // Finally parse the 'finally' block.
@@ skipping 32 matching lines @@
   }
 
   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)));
   }
-  CatchClauseNode* catch_block = new CatchClauseNode(handler_pos,
-                                                     catch_handler_list,
-                                                     context_var,
-                                                     catch_excp_var,
-                                                     catch_trace_var);
+  CatchClauseNode* catch_block =
+      new CatchClauseNode(handler_pos,
+                          catch_handler_list,
+                          Array::ZoneHandle(Array::MakeArray(handler_types)),
+                          context_var,
+                          catch_excp_var,
+                          catch_trace_var);
 
   // Now create the try/catch ast node and return it. If there is a label
   // on the try/catch, close the block that's embedding the try statement
   // and attach the label to it.
   AstNode* try_catch_node =
       new TryCatchNode(try_pos, try_block, end_catch_label,
                        context_var, catch_block, finally_block);
 
   if (try_label != NULL) {
     current_block_->statements->Add(try_catch_node);
@@ skipping 3570 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart