Removed funky Maybe constructor and made fields private.

src/ic/ic-state.cc

 // Copyright 2014 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/v8.h"
 
 #include "src/ic/ic.h"
 #include "src/ic/ic-state.h"
 
 namespace v8 {
@@ skipping 27 matching lines @@
 
 // static
 STATIC_CONST_MEMBER_DEFINITION const int BinaryOpICState::FIRST_TOKEN;
 
 
 // static
 STATIC_CONST_MEMBER_DEFINITION const int BinaryOpICState::LAST_TOKEN;
 
 
 BinaryOpICState::BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state)
-    : fixed_right_arg_(Nothing<int>()), isolate_(isolate) {
+    : fixed_right_arg_(
+          HasFixedRightArgField::decode(extra_ic_state)
+              ? Just(1 << FixedRightArgValueField::decode(extra_ic_state))
+              : Nothing<int>()),
+      isolate_(isolate) {
   op_ =
       static_cast<Token::Value>(FIRST_TOKEN + OpField::decode(extra_ic_state));
-  fixed_right_arg_ =
-      Maybe<int>(HasFixedRightArgField::decode(extra_ic_state),
-                 1 << FixedRightArgValueField::decode(extra_ic_state));
   left_kind_ = LeftKindField::decode(extra_ic_state);
-  if (fixed_right_arg_.has_value) {
-    right_kind_ = Smi::IsValid(fixed_right_arg_.value) ? SMI : INT32;
-  } else {
-    right_kind_ = RightKindField::decode(extra_ic_state);
-  }
+  right_kind_ = fixed_right_arg_.IsJust()
+                    ? (Smi::IsValid(fixed_right_arg_.FromJust()) ? SMI : INT32)
+                    : RightKindField::decode(extra_ic_state);
   result_kind_ = ResultKindField::decode(extra_ic_state);
   DCHECK_LE(FIRST_TOKEN, op_);
   DCHECK_LE(op_, LAST_TOKEN);
 }
 
 
 ExtraICState BinaryOpICState::GetExtraICState() const {
   ExtraICState extra_ic_state =
       OpField::encode(op_ - FIRST_TOKEN) | LeftKindField::encode(left_kind_) |
       ResultKindField::encode(result_kind_) |
-      HasFixedRightArgField::encode(fixed_right_arg_.has_value);
-  if (fixed_right_arg_.has_value) {
+      HasFixedRightArgField::encode(fixed_right_arg_.IsJust());
+  if (fixed_right_arg_.IsJust()) {
     extra_ic_state = FixedRightArgValueField::update(
-        extra_ic_state, WhichPowerOf2(fixed_right_arg_.value));
+        extra_ic_state, WhichPowerOf2(fixed_right_arg_.FromJust()));
   } else {
     extra_ic_state = RightKindField::update(extra_ic_state, right_kind_);
   }
   return extra_ic_state;
 }
 
 
 // static
 void BinaryOpICState::GenerateAheadOfTime(
     Isolate* isolate, void (*Generate)(Isolate*, const BinaryOpICState&)) {
 // TODO(olivf) We should investigate why adding stubs to the snapshot is so
 // expensive at runtime. When solved we should be able to add most binops to
 // the snapshot instead of hand-picking them.
 // Generated list of commonly used stubs
 #define GENERATE(op, left_kind, right_kind, result_kind) \
   do {                                                   \
     BinaryOpICState state(isolate, op);                  \
     state.left_kind_ = left_kind;                        \
-    state.fixed_right_arg_.has_value = false;            \
+    state.fixed_right_arg_ = Nothing<int>();             \
     state.right_kind_ = right_kind;                      \
     state.result_kind_ = result_kind;                    \
     Generate(isolate, state);                            \
   } while (false)
   GENERATE(Token::ADD, INT32, INT32, INT32);
   GENERATE(Token::ADD, INT32, INT32, NUMBER);
   GENERATE(Token::ADD, INT32, NUMBER, NUMBER);
   GENERATE(Token::ADD, INT32, SMI, INT32);
   GENERATE(Token::ADD, NUMBER, INT32, NUMBER);
   GENERATE(Token::ADD, NUMBER, NUMBER, NUMBER);
@@ skipping 81 matching lines @@
   GENERATE(Token::SUB, NUMBER, NUMBER, NUMBER);
   GENERATE(Token::SUB, NUMBER, SMI, NUMBER);
   GENERATE(Token::SUB, SMI, INT32, INT32);
   GENERATE(Token::SUB, SMI, NUMBER, NUMBER);
   GENERATE(Token::SUB, SMI, SMI, SMI);
 #undef GENERATE
 #define GENERATE(op, left_kind, fixed_right_arg_value, result_kind) \
   do {                                                              \
     BinaryOpICState state(isolate, op);                             \
     state.left_kind_ = left_kind;                                   \
-    state.fixed_right_arg_.has_value = true;                        \
-    state.fixed_right_arg_.value = fixed_right_arg_value;           \
+    state.fixed_right_arg_ = Just(fixed_right_arg_value);           \
     state.right_kind_ = SMI;                                        \
     state.result_kind_ = result_kind;                               \
     Generate(isolate, state);                                       \
   } while (false)
   GENERATE(Token::MOD, SMI, 2, SMI);
   GENERATE(Token::MOD, SMI, 4, SMI);
   GENERATE(Token::MOD, SMI, 8, SMI);
   GENERATE(Token::MOD, SMI, 16, SMI);
   GENERATE(Token::MOD, SMI, 32, SMI);
   GENERATE(Token::MOD, SMI, 2048, SMI);
@@ skipping 12 matching lines @@
   }
   DCHECK_NE(GENERIC, result_kind);
   return KindToType(result_kind, zone);
 }
 
 
 std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s) {
   os << "(" << Token::Name(s.op_);
   if (s.CouldCreateAllocationMementos()) os << "_CreateAllocationMementos";
   os << ":" << BinaryOpICState::KindToString(s.left_kind_) << "*";
-  if (s.fixed_right_arg_.has_value) {
-    os << s.fixed_right_arg_.value;
+  if (s.fixed_right_arg_.IsJust()) {
+    os << s.fixed_right_arg_.FromJust();
   } else {
     os << BinaryOpICState::KindToString(s.right_kind_);
   }
   return os << "->" << BinaryOpICState::KindToString(s.result_kind_) << ")";
 }
 
 
 void BinaryOpICState::Update(Handle<Object> left, Handle<Object> right,
                              Handle<Object> result) {
   ExtraICState old_extra_ic_state = GetExtraICState();
 
   left_kind_ = UpdateKind(left, left_kind_);
   right_kind_ = UpdateKind(right, right_kind_);
 
   int32_t fixed_right_arg_value = 0;
   bool has_fixed_right_arg =
       op_ == Token::MOD && right->ToInt32(&fixed_right_arg_value) &&
       fixed_right_arg_value > 0 &&
       base::bits::IsPowerOfTwo32(fixed_right_arg_value) &&
       FixedRightArgValueField::is_valid(WhichPowerOf2(fixed_right_arg_value)) &&
       (left_kind_ == SMI || left_kind_ == INT32) &&
-      (result_kind_ == NONE || !fixed_right_arg_.has_value);
-  fixed_right_arg_ = Maybe<int32_t>(has_fixed_right_arg, fixed_right_arg_value);
-
+      (result_kind_ == NONE || !fixed_right_arg_.IsJust());
+  fixed_right_arg_ =
+      has_fixed_right_arg ? Just(fixed_right_arg_value) : Nothing<int32_t>();
   result_kind_ = UpdateKind(result, result_kind_);
 
   if (!Token::IsTruncatingBinaryOp(op_)) {
     Kind input_kind = Max(left_kind_, right_kind_);
     if (result_kind_ < input_kind && input_kind <= NUMBER) {
       result_kind_ = input_kind;
     }
   }
 
   // We don't want to distinguish INT32 and NUMBER for string add (because
@@ skipping 242 matching lines @@
     case UNIQUE_NAME:
     case OBJECT:
     case GENERIC:
       return GENERIC;
   }
   UNREACHABLE();
   return GENERIC;  // Make the compiler happy.
 }
 }
 }  // namespace v8::internal