Revert "Option to truncate integers to 64 bits, part 2"

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "lib/stacktrace.h"
 #include "platform/assert.h"
@@ skipping 251 matching lines @@
     *value = static_cast<uint64_t>(arg_value);
     return true;
   }
   Thread* thread = arguments->thread();
   ASSERT(thread == Thread::Current());
   REUSABLE_OBJECT_HANDLESCOPE(thread);
   Object& obj = thread->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
-    ASSERT(!Bigint::IsDisabled());
     const Bigint& bigint = Bigint::Cast(obj);
     if (bigint.FitsIntoUint64()) {
       *value = bigint.AsUint64Value();
       return true;
     }
   }
   return false;
 }
 
 static bool GetNativeDoubleArgument(NativeArguments* arguments,
@@ skipping 1723 matching lines @@
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
   const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
-    ASSERT(!Bigint::IsDisabled());
     *fits = Bigint::Cast(int_obj).FitsIntoUint64();
   }
   return Api::Success();
 }
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   // Fast path for Smis.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   API_TIMELINE_DURATION;
   if (Smi::IsValid(value)) {
     NOHANDLESCOPE(thread);
     return Api::NewHandle(thread, Smi::New(static_cast<intptr_t>(value)));
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
   CHECK_CALLBACK_STATE(thread);
   return Api::NewHandle(thread, Integer::New(value));
 }
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromUint64(uint64_t value) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
   API_TIMELINE_DURATION;
-  RawInteger* integer = Integer::NewFromUint64(value);
-  if (integer == Integer::null()) {
-    return Api::NewError("%s: Cannot create Dart integer from value %" Pu64,
-                         CURRENT_FUNC, value);
-  }
-  return Api::NewHandle(T, integer);
+  return Api::NewHandle(T, Integer::NewFromUint64(value));
 }
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
   API_TIMELINE_DURATION;
   const String& str_obj = String::Handle(Z, String::New(str));
-  RawInteger* integer = Integer::New(str_obj);
-  if (integer == Integer::null()) {
-    return Api::NewError("%s: Cannot create Dart integer from string %s",
-                         CURRENT_FUNC, str);
-  }
-  return Api::NewHandle(T, integer);
+  return Api::NewHandle(T, Integer::New(str_obj));
 }
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
   // Fast path for Smis.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *value = Api::SmiValue(integer);
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
   const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success();
   } else {
-    ASSERT(!Bigint::IsDisabled());
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (bigint.FitsIntoInt64()) {
       *value = bigint.AsInt64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as an int64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
@@ skipping 17 matching lines @@
     RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   if (int_obj.IsSmi()) {
     ASSERT(int_obj.IsNegative());
   } else if (int_obj.IsMint()) {
     if (!int_obj.IsNegative()) {
       *value = int_obj.AsInt64Value();
       return Api::Success();
     }
   } else {
-    ASSERT(!Bigint::IsDisabled());
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (bigint.FitsIntoUint64()) {
       *value = bigint.AsUint64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
@@ skipping 4537 matching lines @@
 #endif
 }
 
 DART_EXPORT void Dart_DumpNativeStackTrace(void* context) {
 #ifndef PRODUCT
   Profiler::DumpStackTrace(context);
 #endif
 }
 
 }  // namespace dart