Revert "Improve hashCode for closure objects"

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/become.h"
@@ skipping 6871 matching lines @@
   if (!HasInstantiatedSignature(kCurrentClass)) {
     instantiator_type_arguments = receiver.GetTypeArguments();
   }
   if (!HasInstantiatedSignature(kFunctions)) {
     function_type_arguments = Object::empty_type_arguments().raw();
   }
   return Closure::New(instantiator_type_arguments, function_type_arguments,
                       *this, context);
 }
 
-intptr_t Function::ComputeClosureHash() const {
+RawSmi* Function::GetClosureHashCode() const {
   ASSERT(IsClosureFunction());
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(!obj.IsNull());
+  if (ClosureData::Cast(obj).hash() != Object::null()) {
+    return Smi::RawCast(ClosureData::Cast(obj).hash());
+  }
+  // Hash not yet computed. Compute and cache it.
   const Class& cls = Class::Handle(Owner());
   intptr_t result = String::Handle(name()).Hash();
   result += String::Handle(Signature()).Hash();
   result += String::Handle(cls.Name()).Hash();
-  return result;
+  // Finalize hash value like for strings so that it fits into a smi.
+  result += result << 3;
+  result ^= result >> 11;
+  result += result << 15;
+  result &= ((static_cast<intptr_t>(1) << String::kHashBits) - 1);
+  ClosureData::Cast(obj).set_hash(result);
+  return Smi::New(result);
 }
 
 RawString* Function::BuildSignature(NameVisibility name_visibility) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, 4);
   String& name = String::Handle(zone);
   if (FLAG_reify_generic_functions) {
     const TypeArguments& type_params =
         TypeArguments::Handle(zone, type_parameters());
@@ skipping 399 matching lines @@
 void ClosureData::set_context_scope(const ContextScope& value) const {
   StorePointer(&raw_ptr()->context_scope_, value.raw());
 }
 
 void ClosureData::set_implicit_static_closure(const Instance& closure) const {
   ASSERT(!closure.IsNull());
   ASSERT(raw_ptr()->closure_ == Instance::null());
   StorePointer(&raw_ptr()->closure_, closure.raw());
 }
 
+void ClosureData::set_hash(intptr_t value) const {
+  StorePointer(&raw_ptr()->hash_, static_cast<RawObject*>(Smi::New(value)));
+}
+
 void ClosureData::set_parent_function(const Function& value) const {
   StorePointer(&raw_ptr()->parent_function_, value.raw());
 }
 
 void ClosureData::set_signature_type(const Type& value) const {
   StorePointer(&raw_ptr()->signature_type_, value.raw());
 }
 
 RawClosureData* ClosureData::New() {
   ASSERT(Object::closure_data_class() != Class::null());
@@ skipping 7529 matching lines @@
   }
   return DartEntry::InvokeFunction(eval_func, args);
 }
 
 RawObject* Instance::HashCode() const {
   // TODO(koda): Optimize for all builtin classes and all classes
   // that do not override hashCode.
   return DartLibraryCalls::HashCode(*this);
 }
 
-RawObject* Instance::IdentityHashCode() const {
-  return DartLibraryCalls::IdentityHashCode(*this);
-}
-
 bool Instance::CanonicalizeEquals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
 
   if (other.IsNull() || (this->clazz() != other.clazz())) {
     return false;
   }
 
   {
@@ skipping 6769 matching lines @@
 const char* Closure::ToCString() const {
   const Function& fun = Function::Handle(function());
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
   return OS::SCreate(Thread::Current()->zone(), "Closure: %s%s%s", fun_sig,
                      from, fun_desc);
 }
 
-int64_t Closure::ComputeHash() const {
-  const Function& func = Function::Handle(function());
-  uint32_t result = 0;
-  if (func.IsImplicitInstanceClosureFunction()) {
-    // Implicit instance closures are not unqiue, so combine function's hash
-    // code with identityHashCode of cached receiver.
-    result = static_cast<uint32_t>(func.ComputeClosureHash());
-    const Context& context = Context::Handle(this->context());
-    const Object& receiver = Object::Handle(context.At(0));
-    const Object& receiverHash =
-        Object::Handle(Instance::Cast(receiver).IdentityHashCode());
-    if (receiverHash.IsError()) {
-      Exceptions::PropagateError(Error::Cast(receiverHash));
-      UNREACHABLE();
-    }
-    result = CombineHashes(
-        result, Integer::Cast(receiverHash).AsTruncatedUint32Value());
-  } else {
-    // Explicit closures and implicit static closures are unique,
-    // so identityHashCode of closure object is good enough.
-    const Object& identityHash = Object::Handle(this->IdentityHashCode());
-    if (identityHash.IsError()) {
-      Exceptions::PropagateError(Error::Cast(identityHash));
-      UNREACHABLE();
-    }
-    result = Integer::Cast(identityHash).AsTruncatedUint32Value();
-  }
-  return FinalizeHash(result, String::kHashBits);
-}
-
 RawClosure* Closure::New(const TypeArguments& instantiator_type_arguments,
                          const TypeArguments& function_type_arguments,
                          const Function& function,
                          const Context& context,
                          Heap::Space space) {
   Closure& result = Closure::Handle();
   {
     RawObject* raw =
         Object::Allocate(Closure::kClassId, Closure::InstanceSize(), space);
     NoSafepointScope no_safepoint;
@@ skipping 565 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart