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);

[siva, 2013/01/15 22:04:12]

We should also be ok to not collect any more catch clause types from this point
on right?

e.g:
try {
  ...
  ....
}
on type1 catch() { ... }
catch() { ... }
on type2 catch() { ... }

I know this code looks weird but I assume is still legal.

[hausner, 2013/01/15 22:44:52]

The compiler prints an error message if there are any more catch clauses after a
catch clause that catches type 'dynamic'. So, essentially we can never have a
case where we collect more types since this has to be the last catch clause we
see.

     }
     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