[strong] Refactor ObjectStrength into a replacement for strong boolean args

src/globals.h

 // 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.
 
 #ifndef V8_GLOBALS_H_
 #define V8_GLOBALS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 215 matching lines @@
 // -----------------------------------------------------------------------------
 // Forward declarations for frequently used classes
 // (sorted alphabetically)
 
 class FreeStoreAllocationPolicy;
 template <typename T, class P = FreeStoreAllocationPolicy> class List;
 
 // -----------------------------------------------------------------------------
 // Declarations for use in both the preparser and the rest of V8.
 
-enum ObjectStrength {
-  WEAK,
-  FIRM  // strong object
-};
-
 // The Strict Mode (ECMA-262 5th edition, 4.2.2).
 
 enum LanguageMode {
   // LanguageMode is expressed as a bitmask. Descriptions of the bits:
   STRICT_BIT = 1 << 0,
   STRONG_BIT = 1 << 1,
   LANGUAGE_END,
 
   // Shorthands for some common language modes.
   SLOPPY = 0,
@@ skipping 39 matching lines @@
 
 inline LanguageMode construct_language_mode(bool strict_bit, bool strong_bit) {
   int language_mode = 0;
   if (strict_bit) language_mode |= STRICT_BIT;
   if (strong_bit) language_mode |= STRONG_BIT;
   DCHECK(is_valid_language_mode(language_mode));
   return static_cast<LanguageMode>(language_mode);
 }
 
 
-inline ObjectStrength strength(LanguageMode language_mode) {
-  return is_strong(language_mode) ? FIRM : WEAK;
+// Strong mode behaviour must sometimes be signalled by a two valued enum where
+// caching is involved, to prevent sloppy and strict mode from being incorrectly
+// differentiated.
+enum class Strength : bool {
+  WEAK,   // sloppy, strict behaviour
+  STRONG  // strong behaviour
+};
+
+
+inline bool is_strong(Strength strength) {
+  return strength == Strength::STRONG;
 }
 
 
+inline std::ostream& operator<<(std::ostream& os, const Strength& strength) {
+  return os << (is_strong(strength) ? "strong" : "weak");
+}
+
+
+inline Strength strength(LanguageMode language_mode) {
+  return is_strong(language_mode) ? Strength::STRONG : Strength::WEAK;
+}
+
+
+inline size_t hash_value(Strength strength) {
+  return static_cast<size_t>(strength);
+}
+
+
 // Mask for the sign bit in a smi.
 const intptr_t kSmiSignMask = kIntptrSignBit;
 
 const int kObjectAlignmentBits = kPointerSizeLog2;
 const intptr_t kObjectAlignment = 1 << kObjectAlignmentBits;
 const intptr_t kObjectAlignmentMask = kObjectAlignment - 1;
 
 // Desired alignment for pointers.
 const intptr_t kPointerAlignment = (1 << kPointerSizeLog2);
 const intptr_t kPointerAlignmentMask = kPointerAlignment - 1;
@@ skipping 655 matching lines @@
 inline FunctionKind WithObjectLiteralBit(FunctionKind kind) {
   kind = static_cast<FunctionKind>(kind | FunctionKind::kInObjectLiteral);
   DCHECK(IsValidFunctionKind(kind));
   return kind;
 }
 } }  // namespace v8::internal
 
 namespace i = v8::internal;
 
 #endif  // V8_GLOBALS_H_