Fix issue 20476: creating multiple LocalVariables with same name (finally_ret_val35), confuses the …

runtime/vm/parser.cc

Index: runtime/vm/parser.cc
===================================================================
--- runtime/vm/parser.cc	(revision 39161)
+++ runtime/vm/parser.cc	(working copy)
@@ -115,9 +115,9 @@
 LocalVariable* ParsedFunction::EnsureExpressionTemp() {
   if (!has_expression_temp_var()) {
     LocalVariable* temp =
-        new LocalVariable(function_.token_pos(),
-                          Symbols::ExprTemp(),
-                          Type::ZoneHandle(Type::DynamicType()));
+        new (I) LocalVariable(function_.token_pos(),
+                              Symbols::ExprTemp(),
+                              Type::ZoneHandle(Type::DynamicType()));
     ASSERT(temp != NULL);
     set_expression_temp_var(temp);
   }
@@ -126,6 +126,21 @@
 }
 
 
+LocalVariable* ParsedFunction::EnsureFinallyReturnTemp() {
+  if (!has_finally_return_temp_var()) {
+    LocalVariable* temp = new(I) LocalVariable(
+        function_.token_pos(),
+        String::ZoneHandle(I, Symbols::New(":finally_ret_val")),
+        Type::ZoneHandle(I, Type::DynamicType()));
+    ASSERT(temp != NULL);
+    temp->set_is_final();
+    set_finally_return_temp_var(temp);
+  }
+  ASSERT(has_finally_return_temp_var());
+  return finally_return_temp_var();
+}
+
+
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
@@ -843,6 +858,10 @@
     node_sequence->scope()->AddVariable(
         parsed_function->saved_current_context_var());
   }
+  if (parsed_function->has_finally_return_temp_var()) {
+    node_sequence->scope()->AddVariable(
+        parsed_function->finally_return_temp_var());
+  }
   parsed_function->SetNodeSequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
@@ -1115,15 +1134,16 @@
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
-    context_var = new LocalVariable(token_pos,
-                                    Symbols::SavedTryContextVar(),
-                                    Type::ZoneHandle(I, Type::DynamicType()));
+    context_var = new(I) LocalVariable(
+        token_pos,
+        Symbols::SavedTryContextVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (catch_excp_var == NULL) {
-    catch_excp_var = new LocalVariable(
+    catch_excp_var = new (I) LocalVariable(
         token_pos,
         Symbols::ExceptionVar(),
         Type::ZoneHandle(I, Type::DynamicType()));
@@ -1132,7 +1152,7 @@
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(Symbols::StackTraceVar());
   if (catch_trace_var == NULL) {
-    catch_trace_var = new LocalVariable(
+    catch_trace_var = new (I) LocalVariable(
         token_pos,
         Symbols::StackTraceVar(),
         Type::ZoneHandle(I, Type::DynamicType()));
@@ -6108,8 +6128,8 @@
     // Add the function variable to the scope before parsing the function in
     // order to allow self reference from inside the function.
     function_variable = new(I) LocalVariable(function_pos,
-                                          *variable_name,
-                                          function_type);
+                                             *variable_name,
+                                             function_type);
     function_variable->set_is_final();
     ASSERT(current_block_ != NULL);
     ASSERT(current_block_->scope != NULL);
@@ -7281,9 +7301,8 @@
   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_node->set_saved_return_value_var(

[Florian Schneider, 2014/08/13 10:35:22]

No need to save the variable with the ReturnNode, since there is only one per
function. You can get rid of ReturnNode::saved_return_value_var and just use
parsed_function()->finally_return_temp_var() instead.

[srdjan, 2014/08/13 15:38:55]

Done.

+          parsed_function()->EnsureFinallyReturnTemp());
     }
     return;
   }
@@ -7565,9 +7584,9 @@
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
       InlinedFinallyNode* node = new(I) InlinedFinallyNode(finally_pos,
-                                                        finally_block,
-                                                        context_var,
-                                                        outer_try_index);
+                                                           finally_block,
+                                                           context_var,
+                                                           outer_try_index);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);