[Interpreter] Handles legacy constants in strict mode.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/interpreter/control-flow-builders.h"
@@ skipping 1949 matching lines @@
         if (mode == CONST_LEGACY && op == Token::INIT) {
           // Perform an intialization check for legacy constants.
           builder()
               ->JumpIfNotHole(&end_label)
               .MoveRegister(value_temp, destination)
               .Bind(&end_label)
               .LoadAccumulatorWithRegister(value_temp);
           // Break here because the value should not be stored unconditionally.
           break;
         } else if (mode == CONST_LEGACY && op != Token::INIT) {
-          DCHECK(!is_strict(language_mode()));
-          // Ensure accumulator is in the correct state.
-          builder()->LoadAccumulatorWithRegister(value_temp);
-          // Break here, non-initializing assignments to legacy constants are
-          // ignored.
+          if (is_strict(language_mode())) {
+            builder()->CallRuntime(Runtime::kThrowConstAssignError, Register(),
+                                   0);
+          } else {
+            // Ensure accumulator is in the correct state.
+            builder()->LoadAccumulatorWithRegister(value_temp);
+          }
+          // Non-initializing assignments to legacy constants are ignored
+          // in sloppy mode. Break here to avoid storing into variable.
           break;
         } else {
           BuildHoleCheckForVariableAssignment(variable, op);
           builder()->LoadAccumulatorWithRegister(value_temp);
         }
       }
 
       builder()->StoreAccumulatorInRegister(destination);
       break;
     }
@@ skipping 42 matching lines @@
           builder()
               ->JumpIfNotHole(&end_label)
               .LoadAccumulatorWithRegister(value_temp)
               .StoreContextSlot(context_reg, variable->index())
               .Bind(&end_label);
           builder()->LoadAccumulatorWithRegister(value_temp);
           // Break here because the value should not be stored unconditionally.
           // The above code performs the store conditionally.
           break;
         } else if (mode == CONST_LEGACY && op != Token::INIT) {
-          DCHECK(!is_strict(language_mode()));
-          // Ensure accumulator is in the correct state.
-          builder()->LoadAccumulatorWithRegister(value_temp);
-          // Break here, non-initializing assignments to legacy constants are
-          // ignored.
+          if (is_strict(language_mode())) {
+            builder()->CallRuntime(Runtime::kThrowConstAssignError, Register(),
+                                   0);
+          } else {
+            // Ensure accumulator is in the correct state.
+            builder()->LoadAccumulatorWithRegister(value_temp);
+          }
+          // Non-initializing assignments to legacy constants are ignored
+          // in sloppy mode. Break hear to avoid storing into variable.

[rmcilroy, 2016/04/05 08:44:21]

/s/hear/here

[mythria, 2016/04/11 10:10:05]

Done.

           break;
         } else {
           BuildHoleCheckForVariableAssignment(variable, op);
           builder()->LoadAccumulatorWithRegister(value_temp);
         }
       }
 
       builder()->StoreContextSlot(context_reg, variable->index());
       break;
     }
     case VariableLocation::LOOKUP: {
       if (mode == CONST_LEGACY && op == Token::INIT) {
         register_allocator()->PrepareForConsecutiveAllocations(3);
         Register value = register_allocator()->NextConsecutiveRegister();
         Register context = register_allocator()->NextConsecutiveRegister();
         Register name = register_allocator()->NextConsecutiveRegister();
 
         // InitializeLegacyConstLookupSlot runtime call returns the 'value'
         // passed to it. So, accumulator will have its original contents when
         // runtime call returns.
         builder()
             ->StoreAccumulatorInRegister(value)
             .MoveRegister(execution_context()->reg(), context)
             .LoadLiteral(variable->name())
             .StoreAccumulatorInRegister(name)
             .CallRuntime(Runtime::kInitializeLegacyConstLookupSlot, value, 3);
       } else if (mode == CONST_LEGACY && op != Token::INIT) {
-        // Non-intializing assignments to legacy constants are ignored.
-        DCHECK(!is_strict(language_mode()));
+        // Non-intializing assignments to legacy constants are ignored in sloppy
+        // mode and throws TypeError in strict mode.
+        if (is_strict(language_mode())) {

[Michael Starzinger, 2016/04/04 12:02:24]

nit: The Runtime_StoreLookupSlot_[Strict|Sloppy] method family should handle
this case correctly. I think we can just remove the entire {mode == CONST_LEGACY
&& op != Token::INIT} case and rely on the runtime function to do the right
thing IIUC.

[mythria, 2016/04/11 10:10:05]

Done.

+          builder()->CallRuntime(Runtime::kThrowConstAssignError, Register(),
+                                 0);
+        }
       } else {
         builder()->StoreLookupSlot(variable->name(), language_mode());
       }
       break;
     }
   }
 }
 
 
 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
@@ skipping 1066 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8