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

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 97 matching lines @@
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
 
 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);
   }
   ASSERT(has_expression_temp_var());
   return expression_temp_var();
 }
 
 
+void 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());
+}
+
+
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
 
 void ParsedFunction::AddDeferredPrefix(const LibraryPrefix& prefix) {
   ASSERT(prefix.is_deferred_load());
   ASSERT(!prefix.is_loaded());
@@ skipping 697 matching lines @@
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(func.end_token_pos()));
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
   if (parsed_function->has_saved_current_context_var()) {
     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
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
     // In the case of a local function, only set the instantiator if the
     // receiver (or type arguments parameter of a factory) was captured.
     LocalVariable* instantiator = NULL;
     const bool kTestOnly = true;
     if (parser.current_function().IsInFactoryScope()) {
@@ skipping 251 matching lines @@
   // Move forward to the start of the initializer expression.
   intptr_t ident_pos = TokenPos();
   ExpectIdentifier("identifier expected");
   ExpectToken(Token::kASSIGN);
   intptr_t token_pos = TokenPos();
 
   // Synthesize a try-catch block to wrap the initializer expression.
   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()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
   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()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
   OpenBlock();  // Start try block.
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
   const Field& field = Field::ZoneHandle(I, func.saved_static_field());
   ASSERT(!field.is_const());
@@ skipping 4924 matching lines @@
     // We temporarily use the class of the Function interface.
     const Class& unknown_signature_class = Class::Handle(I,
         Type::Handle(I, Type::Function()).type_class());
     function_type = Type::New(unknown_signature_class,
                               TypeArguments::Handle(I), function_pos);
     function_type.SetIsFinalized();  // No finalization needed.
 
     // 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);
     if (!current_block_->scope->AddVariable(function_variable)) {
       LocalVariable* existing_var =
           current_block_->scope->LookupVariable(function_variable->name(),
                                                 true);
       ASSERT(existing_var != NULL);
       if (existing_var->owner() == current_block_->scope) {
         ReportError(function_pos, "identifier '%s' already defined",
@@ skipping 1149 matching lines @@
     iterator = iterator->outer_try_block();
   }
 }
 
 
 // Add the inlined finally block to the specified node.
 void Parser::AddFinallyBlockToNode(AstNode* node,
                                    InlinedFinallyNode* finally_node) {
   ReturnNode* return_node = node->AsReturnNode();
   if (return_node != NULL) {
+    parsed_function()->EnsureFinallyReturnTemp();
     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,
@@ skipping 260 matching lines @@
   if (CurrentToken() == Token::kFINALLY) {
     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(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);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock();
   }
 
   CatchClauseNode* catch_clause = new(I) CatchClauseNode(
       handler_pos,
@@ skipping 3744 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart