Fix stack height assertion code and free up a bit in the Function tag bits.

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 6767 matching lines @@
     }
     iterator->AddNodeForFinallyInlining(node);
     iterator = iterator->outer_try_block();
   }
 }
 
 
 // Add the inlined finally block to the specified node.
 void Parser::AddFinallyBlockToNode(AstNode* node,
                                    InlinedFinallyNode* finally_node) {
-  if (node->IsReturnNode()) {
-    node->AsReturnNode()->AddInlinedFinallyNode(finally_node);
-  } else {
-    ASSERT(node->IsJumpNode());
-    node->AsJumpNode()->AddInlinedFinallyNode(finally_node);
+  ReturnNode* return_node = node->AsReturnNode();
+  if (return_node != NULL) {
+    return_node->AddInlinedFinallyNode(finally_node);
+    if (return_node->saved_return_value_var() == NULL) {
+      LocalVariable* temp =
+          CreateTempConstVariable(node->token_pos(), "finally_ret_val");
+      return_node->set_saved_return_value_var(temp);
+    }
+    return;
   }
+  JumpNode* jump_node = node->AsJumpNode();
+  ASSERT(jump_node != NULL);
+  jump_node->AddInlinedFinallyNode(finally_node);
 }
 
 
 SequenceNode* Parser::ParseCatchClauses(
     intptr_t handler_pos,
     LocalVariable* exception_var,
     LocalVariable* stack_trace_var,
     const GrowableObjectArray& handler_types,
     bool* needs_stack_trace) {
   // All catch blocks are merged into an if-then-else sequence of the
@@ skipping 242 matching lines @@
   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.
   SequenceNode* finally_block = NULL;
   if (CurrentToken() == Token::kFINALLY) {
-    current_function().set_has_finally(true);
     ConsumeToken();  // Consume the 'finally'.
     const intptr_t finally_pos = TokenPos();
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
@@ skipping 3724 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart