Instance equality

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 12690 matching lines @@
     param = param_values.At(i);
     args.SetAt(i + 1, param);
   }
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(eval_func, args));
   return result.raw();
 }
 
 
 
-bool Instance::Equals(const Instance& other) const {
+bool Instance::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
 
   if (other.IsNull() || (this->clazz() != other.clazz())) {
     return false;
   }
 
   {
     NoGCScope no_gc;
@@ skipping 90 matching lines @@
   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.
   intptr_t index = 0;
   while (index < constants_len) {
     result ^= constants.At(index);
     if (result.IsNull()) {
       break;
     }
-    if (this->Equals(result)) {
+    if (this->CanonicalizeEquals(result)) {
       return result.raw();
     }
     index++;
   }
   // The value needs to be added to the list. Grow the list if
   // it is full.
   result ^= this->raw();
   if (result.IsNew()) {
     // Create a canonical object in old space.
     result ^= Object::Clone(result, Heap::kOld);
@@ skipping 85 matching lines @@
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
   }
   return cls.IsSubtypeOf(type_arguments, other_class, other_type_arguments,
                          bound_error);
 }
 
 
+bool Instance::OperatorEquals(const Instance& other) const {
+  // TODO(koda): Optimize for all builtin classes and all classes
+  // that do not override operator==.
+  const Object& result =
+      Object::Handle(DartLibraryCalls::Equals(*this, other));
+  return result.raw() == Object::bool_true().raw();
+}
+
+
 bool Instance::IsIdenticalTo(const Instance& other) const {
   if (raw() == other.raw()) return true;
   if (IsInteger() && other.IsInteger()) {
-    return Equals(other);
+    return Integer::Cast(*this).Equals(other);
   }
   if (IsDouble() && other.IsDouble()) {
-    if (Equals(other)) return true;
+    if (Double::Cast(*this).CanonicalizeEquals(other)) return true;
     // Check for NaN.
     const Double& a_double = Double::Cast(*this);
     const Double& b_double = Double::Cast(other);
     if (isnan(a_double.value()) && isnan(b_double.value())) {
       return true;
     }
   }
   return false;
 }
 
@@ skipping 2505 matching lines @@
 void Mint::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Number::PrintJSONImpl(stream, ref);
 }
 
 
 void Double::set_value(double value) const {
   raw_ptr()->value_ = value;
 }
 
 
-bool Double::EqualsToDouble(double value) const {
+bool Double::BitwiseEqualsToDouble(double value) const {
   intptr_t value_offset = Double::value_offset();
   void* this_addr = reinterpret_cast<void*>(
       reinterpret_cast<uword>(this->raw_ptr()) + value_offset);
   void* other_addr = reinterpret_cast<void*>(&value);
   return (memcmp(this_addr, other_addr, sizeof(value)) == 0);
 }
 
 
-bool Double::Equals(const Instance& other) const {
+bool Double::OperatorEquals(const Instance& other) const {
+  if (this->IsNull() || other.IsNull()) {
+    return (this->IsNull() && other.IsNull());
+  }
+  if (!other.IsDouble()) {
+    return false;
+  }
+  return this->value() == Double::Cast(other).value();
+}
+
+
+bool Double::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
   if (other.IsNull() || !other.IsDouble()) {
     return false;
   }
-  return EqualsToDouble(Double::Cast(other).value());
+  return BitwiseEqualsToDouble(Double::Cast(other).value());
 }
 
 
 RawDouble* Double::New(double d, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->double_class() != Class::null());
   Double& result = Double::Handle();
   {
     RawObject* raw = Object::Allocate(Double::kClassId,
                                       Double::InstanceSize(),
                                       space);
@@ skipping 21 matching lines @@
   const intptr_t constants_len = constants.Length();
   // Linear search to see whether this value is already present in the
   // list of canonicalized constants.
   Double& canonical_value = Double::Handle();
   intptr_t index = 0;
   while (index < constants_len) {
     canonical_value ^= constants.At(index);
     if (canonical_value.IsNull()) {
       break;
     }
-    if (canonical_value.EqualsToDouble(value)) {
+    if (canonical_value.BitwiseEqualsToDouble(value)) {
       return canonical_value.raw();
     }
     index++;
   }
   // The value needs to be added to the constants list. Grow the list if
   // it is full.
   canonical_value = Double::New(value, Heap::kOld);
   cls.InsertCanonicalConstant(index, canonical_value);
   canonical_value.SetCanonical();
   return canonical_value.raw();
@@ skipping 1880 matching lines @@
   const char* str = ToCString();
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   jsobj.AddPropertyF("id", "objects/bool-%s", str);
   class Class& cls = Class::Handle(this->clazz());
   jsobj.AddProperty("class", cls);
   jsobj.AddPropertyF("valueAsString", "%s", str);
 }
 
 
-bool Array::Equals(const Instance& other) const {
+bool Array::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
   }
 
   // An Array may be compared to an ImmutableArray.
   if (!other.IsArray() || other.IsNull()) {
     return false;
   }
 
@@ skipping 219 matching lines @@
   ASSERT(Length() > 0);
   intptr_t index = Length() - 1;
   const Array& contents = Array::Handle(data());
   const Object& obj = Object::Handle(contents.At(index));
   contents.SetAt(index, Object::null_object());
   SetLength(index);
   return obj.raw();
 }
 
 
-bool GrowableObjectArray::Equals(const Instance& other) const {
+bool GrowableObjectArray::CanonicalizeEquals(const Instance& other) const {
   // If both handles point to the same raw instance they are equal.
   if (this->raw() == other.raw()) {
     return true;
   }
 
   // Other instance must be non null and a GrowableObjectArray.
   if (!other.IsGrowableObjectArray() || other.IsNull()) {
     return false;
   }
 
@@ skipping 889 matching lines @@
     case kGlobal | kMultiLine :
     case kMultiLine:
       return "m";
     default:
       break;
   }
   return "";
 }
 
 
-bool JSRegExp::Equals(const Instance& other) const {
+bool JSRegExp::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
   if (other.IsNull() || !other.IsJSRegExp()) {
     return false;
   }
   const JSRegExp& other_js = JSRegExp::Cast(other);
   // Match the pattern.
   const String& str1 = String::Handle(pattern());
   const String& str2 = String::Handle(other_js.pattern());
@@ skipping 233 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart