Propagate switch statement value for 'eval'

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parser.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 2972 matching lines @@
   // but without requiring downstream code to have special scope handling
   // code for switch statements, desugar into blocks as follows:
   // {  // To group the statements--harmless to evaluate Expression in scope
   //   .tag_variable = Expression;
   //   {  // To give CaseClauses a scope
   //     switch (.tag_variable) { CaseClause* }
   //   }
   // }
 
   Block* switch_block =
-      factory()->NewBlock(NULL, 2, true, RelocInfo::kNoPosition);
+      factory()->NewBlock(NULL, 2, false, RelocInfo::kNoPosition);
   int switch_pos = peek_position();
 
   Expect(Token::SWITCH, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   Expression* tag = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   Variable* tag_variable =
       scope_->NewTemporary(ast_value_factory()->dot_switch_tag_string());
   Assignment* tag_assign = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(tag_variable), tag,
       tag->position());
   Statement* tag_statement =
       factory()->NewExpressionStatement(tag_assign, RelocInfo::kNoPosition);
   switch_block->AddStatement(tag_statement, zone());
 
+  // make statement: undefined;
+  // This is needed so the tag isn't returned as the value, in case the switch
+  // statements don't have a value.
+  switch_block->AddStatement(
+      factory()->NewExpressionStatement(
+          factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
+          RelocInfo::kNoPosition),
+      zone());
+
   Block* cases_block =
-      factory()->NewBlock(NULL, 1, true, RelocInfo::kNoPosition);
+      factory()->NewBlock(NULL, 1, false, RelocInfo::kNoPosition);
   Scope* cases_scope = NewScope(scope_, BLOCK_SCOPE);
 
   SwitchStatement* switch_statement =
       factory()->NewSwitchStatement(labels, switch_pos);
 
   cases_scope->set_start_position(scanner()->location().beg_pos);
   {
     BlockState cases_block_state(&scope_, cases_scope);
     Target target(&this->target_stack_, switch_statement);
 
@@ skipping 3084 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(Context::REFLECT_CONSTRUCT_INDEX, args, pos);
 }
 }  // namespace internal
 }  // namespace v8