Fix equality of implicit closures in the Dart VM.

runtime/vm/parser.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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 739 matching lines @@
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Script& script = Script::Handle(isolate, func.script());
   Parser parser(script, parsed_function, func.token_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::ZoneHandle(isolate, Array::null());
   switch (func.kind()) {
-    case RawFunction::kRegularFunction:
+    case RawFunction::kRegularFunction: {
+    }
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
-    case RawFunction::kConstructor:
+    case RawFunction::kConstructor: {
+      const Class& owner = Class::Handle(func.Owner());
+      const String& name = String::Handle(func.name());
+      if (owner.IsSignatureClass() && name.Equals("==")) {
+        node_sequence = parser.ParseClosureEqualsFunction(func);
+        break;
+      }
+      if (owner.IsSignatureClass() && name.Equals("get:hashCode")) {
+        node_sequence = parser.ParseClosureHashCodeFunction(func);
+        break;
+      }
       // The call to a redirecting factory is redirected.
       ASSERT(!func.IsRedirectingFactory());
       node_sequence = parser.ParseFunc(func, default_parameter_values);
       break;
+    }
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
     case RawFunction::kImplicitStaticFinalGetter:
       node_sequence = parser.ParseStaticFinalGetter(func);
@@ skipping 331 matching lines @@
       Function::ZoneHandle(func.extracted_method_closure()),
       load_receiver,
       NULL);
 
   ReturnNode* return_node = new ReturnNode(ident_pos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
+static const String& PrivateCoreLibName(const String& str) {
+  const Library& core_lib = Library::Handle(Library::CoreLibrary());
+  const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
+  return private_name;
+}
+
+
+SequenceNode* Parser::ParseClosureEqualsFunction(const Function& func) {
+  TRACE_PARSER("ParseClosureEqualsFunction");
+  ParamList params;
+
+  const intptr_t token_pos = func.token_pos();
+  ASSERT(func.token_pos() == 0);
+  ASSERT(current_class().raw() == func.Owner());
+  params.AddReceiver(ReceiverType(), token_pos);
+  params.AddFinalParameter(
+        token_pos,
+        &String::ZoneHandle(Symbols::New("other")),
+        &Type::ZoneHandle(Type::DynamicType()));
+  ASSERT(func.num_fixed_parameters() == 2);  // Receiver, other.
+  ASSERT(!func.HasOptionalParameters());
+
+  // Build local scope for function and populate with the formal parameters.
+  OpenFunctionBlock(func);
+  AddFormalParamsToScope(&params, current_block_->scope);
+
+  // Receiver is local 0.
+  LocalVariable* receiver = current_block_->scope->VariableAt(0);
+  LoadLocalNode* load_receiver = new LoadLocalNode(token_pos, receiver);
+
+  // Other is local 1.
+  LocalVariable* other = current_block_->scope->VariableAt(1);
+  LoadLocalNode* load_other = new LoadLocalNode(token_pos, other);
+
+  ArgumentListNode* arguments = new ArgumentListNode(token_pos);
+  arguments->Add(load_receiver);
+  arguments->Add(load_other);
+
+  const Function& compare_func = Function::ZoneHandle(Resolver::ResolveStatic(
+      Library::Handle(Library::CoreLibrary()),
+      String::Handle(),
+      PrivateCoreLibName(Symbols::ClosureCompareFunction()),
+      arguments->length(),
+      arguments->names(),
+      Resolver::kIsQualified,
+      NULL));
+  ASSERT(!compare_func.IsNull());
+
+  StaticCallNode* call = new StaticCallNode(token_pos, compare_func, arguments);
+
+  ReturnNode* return_node = new ReturnNode(token_pos, call);
+  current_block_->statements->Add(return_node);
+  return CloseBlock();
+}
+
+
+SequenceNode* Parser::ParseClosureHashCodeFunction(const Function& func) {
+  TRACE_PARSER("ParseClosureHashCodeFunction");
+  ParamList params;
+
+  const intptr_t token_pos = func.token_pos();
+  ASSERT(func.token_pos() == 0);
+  ASSERT(current_class().raw() == func.Owner());
+  params.AddReceiver(ReceiverType(), token_pos);
+  ASSERT(func.num_fixed_parameters() == 1);  // Receiver, other.
+  ASSERT(!func.HasOptionalParameters());
+
+  // Build local scope for function and populate with the formal parameters.
+  OpenFunctionBlock(func);
+  AddFormalParamsToScope(&params, current_block_->scope);
+
+  // Receiver is local 0.
+  LocalVariable* receiver = current_block_->scope->VariableAt(0);
+  LoadLocalNode* load_receiver = new LoadLocalNode(token_pos, receiver);
+
+  ArgumentListNode* arguments = new ArgumentListNode(token_pos);
+  arguments->Add(load_receiver);
+
+  const Function& hash_code_func = Function::ZoneHandle(Resolver::ResolveStatic(
+      Library::Handle(Library::CoreLibrary()),
+      String::Handle(),
+      PrivateCoreLibName(Symbols::ClosureHashCodeFunction()),
+      arguments->length(),
+      arguments->names(),
+      Resolver::kIsQualified,
+      NULL));
+  ASSERT(!hash_code_func.IsNull());
+
+  StaticCallNode* call =
+      new StaticCallNode(token_pos, hash_code_func, arguments);
+
+  ReturnNode* return_node = new ReturnNode(token_pos, call);
+  current_block_->statements->Add(return_node);
+  return CloseBlock();
+}
+
+
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc,
                                   Array& default_values) {
   ParamList params;
   // Receiver first.
   intptr_t token_pos = func.token_pos();
   params.AddReceiver(ReceiverType(), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
@@ skipping 478 matching lines @@
   String& name = String::Handle(class_name.raw());
   if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per script basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
     name = Symbols::New(name);
   }
   return core_lib.LookupClass(name, NULL);  // No ambiguity error expected.
 }
 
 
-static const String& PrivateCoreLibName(const String& str) {
-  const Library& core_lib = Library::Handle(Library::CoreLibrary());
-  const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
-  return private_name;
-}
-
-
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
     intptr_t call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg) {
   const intptr_t args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
@@ skipping 8656 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart