VM: Implement closure calls as instance calls.

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1389 matching lines @@
 
   const String& name = String::Handle(func.name());
   const String& getter_name =
       String::ZoneHandle(Symbols::New(String::Handle(Field::GetterName(name))));
   InstanceCallNode* getter_call = new InstanceCallNode(token_pos,
                                                        receiver,
                                                        getter_name,
                                                        no_args);
 
   // Pass arguments 1..n to the closure call.
-  ArgumentListNode* closure_args = new ArgumentListNode(token_pos);
+  ArgumentListNode* args = new ArgumentListNode(token_pos);
   const Array& names = Array::Handle(Array::New(desc.NamedCount(), Heap::kOld));
   // Positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
-    closure_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
+    args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
   // Named parameters.
   for (; i < desc.Count(); i++) {
-    closure_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
+    args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
     intptr_t index = i - desc.PositionalCount();
     names.SetAt(index, String::Handle(desc.NameAt(index)));
   }
-  closure_args->set_names(names);
+  args->set_names(names);
 
-  EnsureSavedCurrentContext();
-  ClosureCallNode* closure_call = new ClosureCallNode(token_pos,
-                                                      getter_call,
-                                                      closure_args);
+  const Class& owner = Class::Handle(func.Owner());
+  ASSERT(!owner.IsNull());
+  AstNode* result = NULL;
+  if (owner.IsSignatureClass() && name.Equals(Symbols::Call())) {
+    EnsureSavedCurrentContext();
+    result = new ClosureCallNode(token_pos, getter_call, args);
+  } else {
+    result = BuildClosureCall(token_pos, getter_call, args);
+  }
 
-  ReturnNode* return_node = new ReturnNode(token_pos, closure_call);
+  ReturnNode* return_node = new ReturnNode(token_pos, result);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
+AstNode* Parser::BuildClosureCall(intptr_t token_pos,
+                                  AstNode* closure,
+                                  ArgumentListNode* arguments) {
+  return new InstanceCallNode(token_pos,
+                              closure,
+                              Symbols::Call(),
+                              arguments);
+}
+
+
 void Parser::SkipBlock() {
   ASSERT(CurrentToken() == Token::kLBRACE);
   GrowableArray<Token::Kind> token_stack(8);
   // Adding the first kLBRACE here, because it will be consumed in the loop
   // right away.
   token_stack.Add(CurrentToken());
   const intptr_t block_start_pos = TokenPos();
   bool is_match = true;
   bool unexpected_token_found = false;
   Token::Kind token;
@@ skipping 448 matching lines @@
                                             LoadReceiver(supercall_pos),
                                             /* is_super_getter */ true,
                                             super_class,
                                             function_name);
     EnsureSavedCurrentContext();
     // 'this' is not passed as parameter to the closure.
     ArgumentListNode* closure_arguments = new ArgumentListNode(supercall_pos);
     for (int i = 1; i < arguments->length(); i++) {
       closure_arguments->Add(arguments->NodeAt(i));
     }
-    return new ClosureCallNode(supercall_pos, closure, closure_arguments);
+    return BuildClosureCall(supercall_pos, closure, closure_arguments);
   }
   if (is_no_such_method) {
     arguments = BuildNoSuchMethodArguments(
         supercall_pos, function_name, *arguments, NULL, true);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
 // Simple test if a node is side effect free.
@@ skipping 4800 matching lines @@
 }
 
 
 AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
   if (condition->IsClosureNode() ||
       (condition->IsStoreLocalNode() &&
        condition->AsStoreLocalNode()->value()->IsClosureNode())) {
     EnsureSavedCurrentContext();
     // Function literal in assert implies a call.
     const intptr_t pos = condition->token_pos();
-    condition = new ClosureCallNode(pos, condition, new ArgumentListNode(pos));
+    condition = BuildClosureCall(pos, condition, new ArgumentListNode(pos));
   } else if (condition->IsConditionalExprNode()) {
     ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
     cond_expr->set_true_expr(InsertClosureCallNodes(cond_expr->true_expr()));
     cond_expr->set_false_expr(InsertClosureCallNodes(cond_expr->false_expr()));
   }
   return condition;
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
@@ skipping 1498 matching lines @@
                                      kNumArguments,
                                      Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
         EnsureSavedCurrentContext();
         closure = new StaticGetterNode(call_pos,
                                        NULL,
                                        false,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
-        return new ClosureCallNode(call_pos, closure, arguments);
+        return BuildClosureCall(call_pos, closure, arguments);
       }
     } else {
       EnsureSavedCurrentContext();
       closure = GenerateStaticFieldLookup(field, call_pos);
-      return new ClosureCallNode(call_pos, closure, arguments);
+      return BuildClosureCall(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos,
                                   cls,
                                   func_name,
                                   arguments,
                                   InvocationMirror::kStatic,
                                   InvocationMirror::kMethod,
                                   NULL);  // No existing function.
   } else if (cls.IsTopLevel() &&
@@ skipping 19 matching lines @@
   return new InstanceCallNode(call_pos, receiver, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   EnsureSavedCurrentContext();
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
-  return new ClosureCallNode(call_pos, closure, arguments);
+  return BuildClosureCall(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
                                            intptr_t ident_pos) {
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field, ident_pos);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
@@ skipping 2619 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart