Unify class ids and snapshot object ids list so that we don't have disparate and sometimes confusin…

vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 251 matching lines @@
 
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
 
 DART_EXPORT bool Dart_IsApiError(Dart_Handle object) {
-  return Api::ClassId(object) == kApiError;
+  return Api::ClassId(object) == kApiErrorCid;
 }
 
 
 DART_EXPORT bool Dart_IsUnhandledExceptionError(Dart_Handle object) {
-  return Api::ClassId(object) == kUnhandledException;
+  return Api::ClassId(object) == kUnhandledExceptionCid;
 }
 
 
 DART_EXPORT bool Dart_IsCompilationError(Dart_Handle object) {
-  return Api::ClassId(object) == kLanguageError;
+  return Api::ClassId(object) == kLanguageErrorCid;
 }
 
 
 DART_EXPORT bool Dart_IsFatalError(Dart_Handle object) {
-  return Api::ClassId(object) == kUnwindError;
+  return Api::ClassId(object) == kUnwindErrorCid;
 }
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
     const Error& error = Error::Cast(obj);
     const char* str = error.ToErrorCString();
@@ skipping 810 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
-  return Api::ClassId(object) == kNullClassId;
+  return Api::ClassId(object) == kNullCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& expected =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj1));
   const Instance& actual =
@@ skipping 90 matching lines @@
   return RawObject::IsIntegerClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
   // Fast path for Smis and Mints.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   intptr_t class_id = Api::ClassId(integer);
-  if (class_id == kSmi || class_id == kMint) {
+  if (class_id == kSmiCid || class_id == kMintCid) {
     *fits = true;
     return Api::Success(isolate);
   }
 
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!BigintOperations::FitsIntoMint(Bigint::Cast(int_obj)));
@@ skipping 149 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_False() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::False(isolate);
 }
 
 
 DART_EXPORT bool Dart_IsBoolean(Dart_Handle object) {
-  return Api::ClassId(object) == kBool;
+  return Api::ClassId(object) == kBoolCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return value ? Api::True(isolate) : Api::False(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Bool& obj = Api::UnwrapBoolHandle(isolate, boolean_obj);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, boolean_obj, Bool);
   }
   *value = obj.value();
   return Api::Success(isolate);
 }
 
 
 // --- Doubles ---
 
 
 DART_EXPORT bool Dart_IsDouble(Dart_Handle object) {
-  return Api::ClassId(object) == kDouble;
+  return Api::ClassId(object) == kDoubleCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, Double::New(value));
 }
 
 
@@ skipping 1215 matching lines @@
            func_kind == RawFunction::kGetterFunction ||
            func_kind == RawFunction::kSetterFunction ||
            func_kind == RawFunction::kConstructor);
   }
 #endif
   return Api::NewHandle(isolate, func.raw());
 }
 
 
 DART_EXPORT bool Dart_IsFunction(Dart_Handle handle) {
-  return Api::ClassId(handle) == kFunction;
+  return Api::ClassId(handle) == kFunctionCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_FunctionName(Dart_Handle function) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Function& func = Api::UnwrapFunctionHandle(isolate, function);
   if (func.IsNull()) {
     RETURN_TYPE_ERROR(isolate, function, Function);
   }
@@ skipping 211 matching lines @@
     const Library& lib = Library::Cast(obj);
     return Api::NewHandle(isolate, lib.LookupFieldAllowPrivate(var_name));
   }
   return Api::NewError(
       "%s expects argument 'target' to be a class or library.",
       CURRENT_FUNC);
 }
 
 
 DART_EXPORT bool Dart_IsVariable(Dart_Handle handle) {
-  return Api::ClassId(handle) == kField;
+  return Api::ClassId(handle) == kFieldCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_VariableName(Dart_Handle variable) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Field& var = Api::UnwrapFieldHandle(isolate, variable);
   if (var.IsNull()) {
     RETURN_TYPE_ERROR(isolate, variable, Field);
   }
@@ skipping 929 matching lines @@
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
-  return Api::ClassId(object) == kLibrary;
+  return Api::ClassId(object) == kLibraryCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library,
                                       Dart_Handle class_name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
@@ skipping 225 matching lines @@
 DART_EXPORT void Dart_InitPerfEventsSupport(Dart_FileWriterFunction function) {
   Dart::set_perf_events_writer(function);
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(Dart_FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart