Remove CONST_LEGACY VariableMode

src/ast/variables.h

 // Copyright 2011 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.
 
 #ifndef V8_AST_VARIABLES_H_
 #define V8_AST_VARIABLES_H_
 
 #include "src/ast/ast-value-factory.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 // The AST refers to variables via VariableProxies - placeholders for the actual
 // variables. Variables themselves are never directly referred to from the AST,
 // they are maintained by scopes, and referred to from VariableProxies and Slots
 // after binding and variable allocation.
 class Variable final : public ZoneObject {
  public:
   enum Kind : uint8_t {
     NORMAL,
     FUNCTION,
     THIS,
     ARGUMENTS,
-    kLastKind = ARGUMENTS
+    SLOPPY_FUNCTION_NAME,
+    kLastKind = SLOPPY_FUNCTION_NAME
   };
 
   Variable(Scope* scope, const AstRawString* name, VariableMode mode, Kind kind,
            InitializationFlag initialization_flag,
            MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
 
   // Printing support
   static const char* Mode2String(VariableMode mode);
 
   // The source code for an eval() call may refer to a variable that is
@@ skipping 33 matching lines @@
   }
   bool IsParameter() const { return location() == VariableLocation::PARAMETER; }
   bool IsStackLocal() const { return location() == VariableLocation::LOCAL; }
   bool IsStackAllocated() const { return IsParameter() || IsStackLocal(); }
   bool IsContextSlot() const { return location() == VariableLocation::CONTEXT; }
   bool IsLookupSlot() const { return location() == VariableLocation::LOOKUP; }
   bool IsGlobalObjectProperty() const;
   bool IsStaticGlobalObjectProperty() const;
 
   bool is_dynamic() const { return IsDynamicVariableMode(mode()); }
-  bool is_const_mode() const { return IsImmutableVariableMode(mode()); }
   bool binding_needs_init() const {
     DCHECK(initialization_flag() != kNeedsInitialization ||
            IsLexicalVariableMode(mode()));
     return initialization_flag() == kNeedsInitialization;
   }
+  bool throw_on_const_assignment(LanguageMode language_mode) const {
+    return kind() != SLOPPY_FUNCTION_NAME || is_strict(language_mode);
+  }
 
   bool is_function() const { return kind() == FUNCTION; }
   bool is_this() const { return kind() == THIS; }
   bool is_arguments() const { return kind() == ARGUMENTS; }
+  bool is_sloppy_function_name() const {
+    return kind() == SLOPPY_FUNCTION_NAME;
+  }
 
   Variable* local_if_not_shadowed() const {
     DCHECK(mode() == DYNAMIC_LOCAL && local_if_not_shadowed_ != NULL);
     return local_if_not_shadowed_;
   }
 
   void set_local_if_not_shadowed(Variable* local) {
     local_if_not_shadowed_ = local;
   }
 
@@ skipping 22 matching lines @@
   // If this field is set, this variable references the stored locally bound
   // variable, but it might be shadowed by variable bindings introduced by
   // sloppy 'eval' calls between the reference scope (inclusive) and the
   // binding scope (exclusive).
   Variable* local_if_not_shadowed_;
   int index_;
   int initializer_position_;
   uint16_t bit_field_;
 
   class VariableModeField : public BitField16<VariableMode, 0, 3> {};
-  class KindField : public BitField16<Kind, VariableModeField::kNext, 2> {};
+  class KindField : public BitField16<Kind, VariableModeField::kNext, 3> {};
   class LocationField
       : public BitField16<VariableLocation, KindField::kNext, 3> {};
   class ForceContextAllocationField
       : public BitField16<bool, LocationField::kNext, 1> {};
   class IsUsedField
       : public BitField16<bool, ForceContextAllocationField::kNext, 1> {};
   class InitializationFlagField
       : public BitField16<InitializationFlag, IsUsedField::kNext, 2> {};
   class MaybeAssignedFlagField
       : public BitField16<MaybeAssignedFlag, InitializationFlagField::kNext,
                           2> {};
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_VARIABLES_H_