Instance equality

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 4112 matching lines @@
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnwindError, Error);
   friend class Class;
 };
 
 
 // Instance is the base class for all instance objects (aka the Object class
 // in Dart source code.
 class Instance : public Object {
  public:
-  virtual bool Equals(const Instance& other) const;
+  // Equality and identity testing.
+  // 1. OperatorEquals: true iff 'this == other' is true in Dart code.

[rmacnak, 2014/05/12 17:15:17]

Reminds me of Self's equivalent (=), indistinguishable (==), and identical
(===).

[koda, 2014/05/12 17:41:43]

Maybe we should add SameSameButDifferent :)

+  // 2. IsIdenticalTo: true iff 'identical(this, other)' is true in Dart code.
+  // 3. CanonicalizeEquals: used to canonicalize compile-time constants, e.g.,

[hausner, 2014/05/12 17:09:30]

Would it make sense to rename this as BitwiseEquals throughout?

[koda, 2014/05/12 17:41:43]

That is almost true, but not technically true for GrowableObjectArray, where it
actually looks inside its single Array field. Also, there still seems to be some
dispute about whether we really should canonicalize NaNs using bitwise equality
(issue 18738).

I mostly want to minimize the risk that people make false assumptions.

+  //    using bitwise equality of fields and list elements.
+  // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
+  // String and Integer.
+  virtual bool OperatorEquals(const Instance& other) const;
+  bool IsIdenticalTo(const Instance& other) const;
+  virtual bool CanonicalizeEquals(const Instance& other) const;
+
   // Returns Instance::null() if instance cannot be canonicalized.
   // Any non-canonical number of string will be canonicalized here.
   // An instance cannot be canonicalized if it still contains non-canonical
   // instances in its fields.
   // Returns error in error_str, pass NULL if an error cannot occur.
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const;
 
   // Returns true if all fields are OK for canonicalization.
   virtual bool CheckAndCanonicalizeFields(const char** error_str) const;
 
   RawObject* GetField(const Field& field) const {
     return *FieldAddr(field);
   }
 
   void SetField(const Field& field, const Object& value) const {
     field.UpdateGuardedCidAndLength(value);
     StorePointer(FieldAddr(field), value.raw());
   }
 
   RawType* GetType() const;
 
   virtual RawTypeArguments* GetTypeArguments() const;
   virtual void SetTypeArguments(const TypeArguments& value) const;
 
   // Check if the type of this instance is a subtype of the given type.
   bool IsInstanceOf(const AbstractType& type,
                     const TypeArguments& type_instantiator,
                     Error* bound_error) const;
 
-  // Check whether this instance is identical to the argument according to the
-  // specification of dare:core's identical().
-  bool IsIdenticalTo(const Instance& other) const;
-
   bool IsValidNativeIndex(int index) const {
     return ((index >= 0) && (index < clazz()->ptr()->num_native_fields_));
   }
 
   intptr_t* NativeFieldsDataAddr() const;
   inline intptr_t GetNativeField(int index) const;
   inline void GetNativeFields(uint16_t num_fields,
                               intptr_t* field_values) const;
 
   uint16_t NumNativeFields() const {
@@ skipping 124 matching lines @@
   virtual bool IsMalformedOrMalbounded() const;
   virtual RawLanguageError* error() const;
   virtual void set_error(const LanguageError& value) const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual intptr_t token_pos() const;
   virtual bool IsInstantiated(GrowableObjectArray* trail = NULL) const;
+  virtual bool CanonicalizeEquals(const Instance& other) const {
+    return Equals(other);
+  }
   virtual bool Equals(const Instance& other) const {
     return IsEquivalent(other);
   }
   virtual bool IsEquivalent(const Instance& other,
                             GrowableObjectArray* trail = NULL) const;
   virtual bool IsRecursive() const;
 
   // Instantiate this type using the given type argument vector.
   // Return a new type, or return 'this' if it is already instantiated.
   // If bound_error is not NULL, it may be set to reflect a bound error.
@@ skipping 546 matching lines @@
       uint64_t value, Heap::Space space = Heap::kNew);
 
   // Returns a canonical Integer object allocated in the old gen space.
   static RawInteger* NewCanonical(const String& str);
 
   // Do not throw JavascriptIntegerOverflow if 'silent' is true.
   static RawInteger* New(int64_t value,
                          Heap::Space space = Heap::kNew,
                          const bool silent = false);
 
+  virtual bool OperatorEquals(const Instance& other) const {
+    return Equals(other);
+  }
+  virtual bool CanonicalizeEquals(const Instance& other) const {
+    return Equals(other);
+  }
+  virtual bool Equals(const Instance& other) const {
+    UNREACHABLE();
+    return false;
+  }
+
   // Integer is an abstract class.
   virtual bool IsZero() const {
     UNREACHABLE();
     return false;
   }
   virtual bool IsNegative() const {
     // Number is an abstract class.
     UNREACHABLE();
     return false;
   }
@@ skipping 244 matching lines @@
 
 
 // Class Double represents class Double in corelib_impl, which implements
 // abstract class double in corelib.
 class Double : public Number {
  public:
   double value() const {
     return raw_ptr()->value_;
   }
 
-  bool EqualsToDouble(double value) const;
-  virtual bool Equals(const Instance& other) const;
+  bool BitwiseEqualsToDouble(double value) const;
+  virtual bool OperatorEquals(const Instance& other) const;
+  virtual bool CanonicalizeEquals(const Instance& other) const;
 
   static RawDouble* New(double d, Heap::Space space = Heap::kNew);
 
   static RawDouble* New(const String& str, Heap::Space space = Heap::kNew);
 
   // Returns a canonical double object allocated in the old gen space.
   static RawDouble* NewCanonical(double d);
 
   // Returns a canonical double object (allocated in the old gen space) or
   // Double::null() if str points to a string that does not convert to a
@@ skipping 99 matching lines @@
 
   // Compares to an array of UTF-8 encoded characters.
   bool Equals(const uint8_t* characters, intptr_t len) const;
 
   // Compares to an array of UTF-16 encoded characters.
   bool Equals(const uint16_t* characters, intptr_t len) const;
 
   // Compares to an array of UTF-32 encoded characters.
   bool Equals(const int32_t* characters, intptr_t len) const;
 
+  virtual bool OperatorEquals(const Instance& other) const {
+    return Equals(other);
+  }
+  virtual bool CanonicalizeEquals(const Instance& other) const {
+    return Equals(other);
+  }
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
 
   bool StartsWith(const String& other) const;
 
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const;
 
   bool IsSymbol() const { return raw()->IsCanonical(); }
 
@@ skipping 610 matching lines @@
     return raw_ptr()->type_arguments_;
   }
   virtual void SetTypeArguments(const TypeArguments& value) const {
     // An Array is raw or takes one type argument. However, its type argument
     // vector may be longer than 1 due to a type optimization reusing the type
     // argument vector of the instantiator.
     ASSERT(value.IsNull() || ((value.Length() >= 1) && value.IsInstantiated()));
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
 
-  virtual bool Equals(const Instance& other) const;
+  virtual bool CanonicalizeEquals(const Instance& other) const;
 
   static const intptr_t kBytesPerElement = kWordSize;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawArray, type_arguments_);
   }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawArray) == OFFSET_OF_RETURNED_VALUE(RawArray, data));
@@ skipping 139 matching lines @@
   virtual void SetTypeArguments(const TypeArguments& value) const {
     // A GrowableObjectArray is raw or takes one type argument. However, its
     // type argument vector may be longer than 1 due to a type optimization
     // reusing the type argument vector of the instantiator.
     ASSERT(value.IsNull() || ((value.Length() >= 1) && value.IsInstantiated()));
     const Array& contents = Array::Handle(data());
     contents.SetTypeArguments(value);
     StorePointer(&raw_ptr()->type_arguments_, value.raw());
   }
 
-  virtual bool Equals(const Instance& other) const;
+  virtual bool CanonicalizeEquals(const Instance& other) const;
 
   virtual RawInstance* CheckAndCanonicalize(const char** error_str) const {
     UNREACHABLE();
     return Instance::null();
   }
 
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawGrowableObjectArray, type_arguments_);
   }
 
@@ skipping 690 matching lines @@
   void set_is_global() const { raw_ptr()->flags_ |= kGlobal; }
   void set_is_ignore_case() const { raw_ptr()->flags_ |= kIgnoreCase; }
   void set_is_multi_line() const { raw_ptr()->flags_ |= kMultiLine; }
   void set_is_simple() const { raw_ptr()->type_ = kSimple; }
   void set_is_complex() const { raw_ptr()->type_ = kComplex; }
 
   void* GetDataStartAddress() const;
   static RawJSRegExp* FromDataStartAddress(void* data);
   const char* Flags() const;
 
-  virtual bool Equals(const Instance& other) const;
+  virtual bool CanonicalizeEquals(const Instance& other) const;
 
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawJSRegExp) == OFFSET_OF(RawJSRegExp, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
@@ skipping 262 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_