Fix equality of implicit closures in the Dart VM.

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 1829 matching lines @@
                     false,  // Not const.
                     false,  // Not abstract.
                     false,  // Not external.
                     *this,
                     0));  // No token position.
   ArgumentsDescriptor desc(args_desc);
   invocation.set_num_fixed_parameters(desc.PositionalCount());
   invocation.SetNumOptionalParameters(desc.NamedCount(),
                                       false);  // Not positional.
   invocation.set_parameter_types(Array::Handle(Array::New(desc.Count(),
-                                                         Heap::kOld)));
+                                                          Heap::kOld)));
   invocation.set_parameter_names(Array::Handle(Array::New(desc.Count(),
-                                                         Heap::kOld)));
+                                                          Heap::kOld)));
   // Receiver.
   invocation.SetParameterTypeAt(0, Type::Handle(Type::DynamicType()));
   invocation.SetParameterNameAt(0, Symbols::This());
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); i++) {
     invocation.SetParameterTypeAt(i, Type::Handle(Type::DynamicType()));
     char name[64];
     OS::SNPrint(name, 64, ":p%"Pd, i);
     invocation.SetParameterNameAt(i, String::Handle(Symbols::New(name)));
@@ skipping 2752 matching lines @@
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     parent_owner,
                     token_pos));
   result.set_parent_function(parent);
   return result.raw();
 }
 
 
+static RawFunction* CreateClosureEqualsFunction(const Class& owner) {
+  Function& result = Function::Handle(
+      Function::New(Symbols::EqualOperator(),
+                    RawFunction::kRegularFunction,
+                    false,  // Not static.
+                    false,  // Not const.
+                    false,  // Not abstract.
+                    false,  // Not external.
+                    owner,
+                    0));  // No token position.
+  const intptr_t num_args = 2;
+  result.set_num_fixed_parameters(num_args);
+  result.SetNumOptionalParameters(0,
+                                  false);  // Not positional.
+  result.set_parameter_types(Array::Handle(Array::New(num_args,
+                                                      Heap::kOld)));
+  result.set_parameter_names(Array::Handle(Array::New(num_args,
+                                                      Heap::kOld)));
+  // Receiver.
+  result.SetParameterTypeAt(0, Type::Handle(Type::DynamicType()));
+  result.SetParameterNameAt(0, Symbols::This());
+  // Other.
+  result.SetParameterTypeAt(1, Type::Handle(Type::DynamicType()));
+  result.SetParameterNameAt(1, String::Handle(Symbols::New("other")));
+
+  result.set_result_type(Type::Handle(Type::BoolType()));
+  return result.raw();
+}
+
+
+static RawFunction* CreateClosureHashCodeFunction(const Class& owner) {
+  Function& result = Function::Handle(
+      Function::New(Symbols::HashCode(),
+                    RawFunction::kGetterFunction,
+                    false,  // Not static.
+                    false,  // Not const.
+                    false,  // Not abstract.
+                    false,  // Not external.
+                    owner,
+                    0));  // No token position.
+  const intptr_t num_args = 1;
+  result.set_num_fixed_parameters(num_args);
+  result.SetNumOptionalParameters(0,
+                                  false);  // Not positional.
+  result.set_parameter_types(Array::Handle(Array::New(num_args,
+                                                      Heap::kOld)));
+  result.set_parameter_names(Array::Handle(Array::New(num_args,
+                                                      Heap::kOld)));
+  // Receiver.
+  result.SetParameterTypeAt(0, Type::Handle(Type::DynamicType()));
+  result.SetParameterNameAt(0, Symbols::This());
+
+  result.set_result_type(Type::Handle(Type::IntType()));
+  return result.raw();
+}
+
+
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
   const String& closure_name = String::Handle(name());
   const Function& closure_function = Function::Handle(
       NewClosureFunction(closure_name, *this, token_pos()));
@@ skipping 49 matching lines @@
   ASSERT(!library.IsNull());
   const String& signature = String::Handle(closure_function.Signature());
   Class& signature_class = Class::ZoneHandle(
       library.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
     const Script& script = Script::Handle(this->script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script,
                                                closure_function.token_pos());
+    // Add == function to implicit instance closures.

[Ivan Posva, 2013/08/09 21:24:30]

This will not work because f, g and h in the example below do have the same
signature class.

class A {
  foo() => "A.foo";
}
bar() => "bar";
baz() => () => "I don't even…";

main() {
  var a = new A();
  var f = a.foo;
  var g = bar;
  var h = baz();
}

And thus you will be missing the injected functions depending on the order of
execution. Let's talk offline about the proper approach for this problem.

Thanks,
-Ivan

[Florian Schneider, 2013/08/12 09:32:12]

Done. You're right. I'll make sure that == and hashcode is added to all
signature classes by moving the code that creates them to
Class::NewSignatureClass. 

On 2013/08/09 21:24:30, Ivan Posva wrote:

+    if (!closure_function.is_static()) {
+      const Function& equals_function =
+          Function::Handle(CreateClosureEqualsFunction(signature_class));
+      signature_class.AddFunction(equals_function);
+      const Function& hash_code_function =
+          Function::Handle(CreateClosureHashCodeFunction(signature_class));
+      signature_class.AddFunction(hash_code_function);
+    }
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
   const Type& signature_type = Type::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
     ClassFinalizer::FinalizeType(
         signature_class, signature_type, ClassFinalizer::kCanonicalize);
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
@@ skipping 9868 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart