Pass closure object as first implicit argument to closure functions.

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/bigint_operations.h"
@@ skipping 3391 matching lines @@
 intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
     if (is_static()) {
       ASSERT(IsFactory());
       return 1;  // Type arguments.
     } else {
       ASSERT(IsConstructor());
       return 2;  // Instance, phase.
     }
   }
-  if (!is_static() &&
-      kind() != RawFunction::kClosureFunction &&
-      kind() != RawFunction::kSignatureFunction) {
+  if ((kind() == RawFunction::kClosureFunction) ||
+      (kind() == RawFunction::kSignatureFunction)) {
+    return 1;  // Closure object.
+  }
+  if (!is_static()) {
     // Closure functions defined inside instance (i.e. non-static) functions are
     // marked as non-static, but they do not have a receiver.
+    // Closures are handled above.
+    ASSERT((kind() != RawFunction::kClosureFunction) &&
+           (kind() != RawFunction::kSignatureFunction));
     return 1;  // Receiver.
   }
   return 0;  // No implicit parameters.
 }
 
 
 bool Function::AreValidArgumentCounts(int num_arguments,
                                       int num_named_arguments,
                                       String* error_message) const {
   if (num_named_arguments > NumOptionalNamedParameters()) {
@@ skipping 432 matching lines @@
     context_scope ^= ContextScope::New(0);
   } else {
     context_scope ^= LocalScope::CreateImplicitClosureScope(*this);
   }
   closure_function.set_context_scope(context_scope);
 
   // Set closure function's result type to this result type.
   closure_function.set_result_type(AbstractType::Handle(result_type()));
 
   // Set closure function's formal parameters to this formal parameters,
-  // removing the receiver if this is an instance method.
+  // removing the receiver if this is an instance method and adding the closure
+  // object as first parameter.
+  const int kClosure = 1;
   const int has_receiver = is_static() ? 0 : 1;
-  const int num_fixed_params = num_fixed_parameters() - has_receiver;
+  const int num_fixed_params = kClosure - has_receiver + num_fixed_parameters();
   const int num_opt_params = NumOptionalParameters();
   const bool has_opt_pos_params = HasOptionalPositionalParameters();
   const int num_params = num_fixed_params + num_opt_params;
   closure_function.set_num_fixed_parameters(num_fixed_params);
   closure_function.SetNumOptionalParameters(num_opt_params, has_opt_pos_params);
   closure_function.set_parameter_types(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   closure_function.set_parameter_names(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   AbstractType& param_type = AbstractType::Handle();
   String& param_name = String::Handle();
-  for (int i = 0; i < num_params; i++) {
-    param_type = ParameterTypeAt(i + has_receiver);
+  // Add implicit closure object parameter.
+  param_type = Type::DynamicType();
+  closure_function.SetParameterTypeAt(0, param_type);
+  param_name = Symbols::ClosureParameter();
+  closure_function.SetParameterNameAt(0, param_name);
+  for (int i = kClosure; i < num_params; i++) {
+    param_type = ParameterTypeAt(has_receiver - kClosure + i);
     closure_function.SetParameterTypeAt(i, param_type);
-    param_name = ParameterNameAt(i + has_receiver);
+    param_name = ParameterNameAt(has_receiver - kClosure + i);
     closure_function.SetParameterNameAt(i, param_name);
   }
 
   // Lookup or create a new signature class for the closure function in the
   // library of the owner class.
   const Class& owner_class = Class::Handle(Owner());
   ASSERT(!owner_class.IsNull() && (Owner() == closure_function.Owner()));
   const Library& library = Library::Handle(owner_class.library());
   ASSERT(!library.IsNull());
   const String& signature = String::Handle(closure_function.Signature());
@@ skipping 72 matching lines @@
     }
   }
   AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   pieces.Add(kLParen);
-  for (intptr_t i = 0; i < num_fixed_params; i++) {
+  intptr_t i = 0;
+  if (name_visibility == kUserVisibleName) {
+    // Hide implicit parameters.
+    i = NumImplicitParameters();
+  }
+  while (i < num_fixed_params) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
     if (instantiate && !param_type.IsInstantiated()) {
       param_type = param_type.InstantiateFrom(instantiator);
     }
     name = param_type.BuildName(name_visibility);
     pieces.Add(name);
     if (i != (num_params - 1)) {
       pieces.Add(kCommaSpace);
     }
+    i++;
   }
   if (num_opt_params > 0) {
     if (num_opt_pos_params > 0) {
       pieces.Add(kLBracket);
     } else {
       pieces.Add(kLBrace);
     }
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       // The parameter name of an optional positional parameter does not need
       // to be part of the signature, since it is not used.
@@ skipping 7933 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart