Cleanups: addressed your comments from https://codereview.chromium.org/14962008/

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 10326 matching lines @@
 }
 
 
 RawInteger* Integer::New(const String& str, Heap::Space space) {
   // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
     const Bigint& big = Bigint::Handle(Bigint::New(str, space));
     ASSERT(!BigintOperations::FitsIntoSmi(big));
-    ASSERT(!BigintOperations::FitsIntoMint(big));
+    ASSERT(!BigintOperations::FitsIntoInt64(big));
     return big.raw();
   }
   return Integer::New(value, space);
 }
 
 
 RawInteger* Integer::NewCanonical(const String& str) {
   // We are not supposed to have integers represented as two byte strings.
   ASSERT(str.IsOneByteString());
   int64_t value;
   if (!OS::StringToInt64(str.ToCString(), &value)) {
     const Bigint& big = Bigint::Handle(Bigint::NewCanonical(str));
     ASSERT(!BigintOperations::FitsIntoSmi(big));
-    ASSERT(!BigintOperations::FitsIntoMint(big));
+    ASSERT(!BigintOperations::FitsIntoInt64(big));
     return big.raw();
   }
   if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
     return Smi::New(value);
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawInteger* Integer::New(int64_t value, Heap::Space space) {
@@ skipping 31 matching lines @@
       return Smi::New(mint.value());
     } else {
       return raw();
     }
   }
   ASSERT(IsBigint());
   Bigint& big_value = Bigint::Handle();
   big_value ^= raw();
   if (BigintOperations::FitsIntoSmi(big_value)) {
     return BigintOperations::ToSmi(big_value);
-  } else if (BigintOperations::FitsIntoMint(big_value)) {
-    return Mint::New(BigintOperations::ToMint(big_value));
+  } else if (BigintOperations::FitsIntoInt64(big_value)) {
+    return Mint::New(BigintOperations::ToInt64(big_value));
   } else {
     return big_value.raw();
   }
 }
 
 
 RawInteger* Integer::ArithmeticOp(Token::Kind operation,
                                   const Integer& other) const {
   // In 32-bit mode, the result of any operation between two Smis will fit in a
   // 32-bit signed result, except the product of two Smis, which will be 64-bit.
@@ skipping 80 matching lines @@
         }
         default:
           UNIMPLEMENTED();
         }
       }
     }
   }
   const Bigint& left_big = Bigint::Handle(AsBigint());
   const Bigint& right_big = Bigint::Handle(other.AsBigint());
   const Bigint& result =
-      Bigint::Handle(left_big.ArithmeticOp(operation, right_big));
+      Bigint::Handle(left_big.BigArithmeticOp(operation, right_big));
   return Integer::Handle(result.AsValidInteger()).raw();
 }
 
 
 static bool Are64bitOperands(const Integer& op1, const Integer& op2) {
   return !op1.IsBigint() && !op2.IsBigint();
 }
 
 
 RawInteger* Integer::BitOp(Token::Kind kind, const Integer& other) const {
@@ skipping 243 matching lines @@
     int64_t b = other.AsInt64Value();
     if (a < b) {
       return -1;
     } else if (a > b) {
       return 1;
     } else {
       return 0;
     }
   }
   if (other.IsBigint()) {
-    ASSERT(!BigintOperations::FitsIntoMint(Bigint::Cast(other)));
+    ASSERT(!BigintOperations::FitsIntoInt64(Bigint::Cast(other)));
     if (this->IsNegative() == other.IsNegative()) {
       return this->IsNegative() ? 1 : -1;
     }
     return this->IsNegative() ? -1 : 1;
   }
   UNREACHABLE();
   return 0;
 }
 
 
@@ skipping 121 matching lines @@
   } else {
     ASSERT(IsBigint());
     Bigint& big = Bigint::Handle();
     big ^= raw();
     ASSERT(!BigintOperations::FitsIntoSmi(big));
     return big.raw();
   }
 }
 
 
-RawBigint* Bigint::ArithmeticOp(Token::Kind operation,
-                                const Bigint& other) const {
+RawBigint* Bigint::BigArithmeticOp(Token::Kind operation,
+                                   const Bigint& other) const {
   switch (operation) {
     case Token::kADD:
       return BigintOperations::Add(*this, other);
     case Token::kSUB:
       return BigintOperations::Subtract(*this, other);
     case Token::kMUL:
       return BigintOperations::Multiply(*this, other);
     case Token::kTRUNCDIV:
       return BigintOperations::Divide(*this, other);
     case Token::kMOD:
@@ skipping 31 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 
 RawBigint* Bigint::New(const String& str, Heap::Space space) {
   const Bigint& result = Bigint::Handle(
       BigintOperations::NewFromCString(str.ToCString(), space));
-  ASSERT(!BigintOperations::FitsIntoMint(result));
+  ASSERT(!BigintOperations::FitsIntoInt64(result));
   return result.raw();
 }
 
 
 RawBigint* Bigint::NewCanonical(const String& str) {
   const Bigint& value = Bigint::Handle(
       BigintOperations::NewFromCString(str.ToCString(), Heap::kOld));
-  ASSERT(!BigintOperations::FitsIntoMint(value));
+  ASSERT(!BigintOperations::FitsIntoInt64(value));
   const Class& cls =
       Class::Handle(Isolate::Current()->object_store()->bigint_class());
   const Array& constants = Array::Handle(cls.constants());
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Bigint& canonical_value = Bigint::Handle();
   intptr_t index = 0;
   while (index < constants_len) {
     canonical_value ^= constants.At(index);
@@ skipping 12 matching lines @@
   return value.raw();
 }
 
 
 double Bigint::AsDoubleValue() const {
   return Double::Handle(BigintOperations::ToDouble(*this)).value();
 }
 
 
 int64_t Bigint::AsInt64Value() const {
-  if (!BigintOperations::FitsIntoMint(*this)) {
+  if (!BigintOperations::FitsIntoInt64(*this)) {
     UNREACHABLE();
   }
-  return BigintOperations::ToMint(*this);
+  return BigintOperations::ToInt64(*this);
 }
 
 
 // For positive values: Smi < Mint < Bigint.
 int Bigint::CompareWith(const Integer& other) const {
   ASSERT(!FitsIntoSmi(*this));
-  ASSERT(!BigintOperations::FitsIntoMint(*this));
+  ASSERT(!BigintOperations::FitsIntoInt64(*this));
   if (other.IsBigint()) {
     return BigintOperations::Compare(*this, Bigint::Cast(other));
   }
   if (this->IsNegative() == other.IsNegative()) {
     return this->IsNegative() ? -1 : 1;
   }
   return this->IsNegative() ? -1 : 1;
 }
 
 
@@ skipping 2221 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart