Pass closure object as first implicit argument to closure functions.

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 136 matching lines @@
   }
   return NULL;
 }
 
 
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   const intptr_t num_fixed_params = function().num_fixed_parameters();
   const intptr_t num_opt_params = function().NumOptionalParameters();
   intptr_t num_params = num_fixed_params + num_opt_params;
-  const bool is_native_instance_closure =
-      function().is_native() && function().IsImplicitInstanceClosureFunction();
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
-  if ((num_opt_params == 0) && !is_native_instance_closure) {
+  if (num_opt_params == 0) {
     // Parameter i will be at fp[1 + num_params - i] and local variable
     // j will be at fp[kFirstLocalSlotIndex - j].
     ASSERT(GetSavedArgumentsDescriptorVar() == NULL);
     first_parameter_index_ = 1 + num_params;
     first_stack_local_index_ = kFirstLocalSlotIndex;
     num_copied_params_ = 0;
   } else {
     // Parameter i will be at fp[kFirstLocalSlotIndex - i] and local variable
     // j will be at fp[kFirstLocalSlotIndex - num_params - j].
     // The saved argument descriptor variable must be allocated similarly to
     // a parameter, so that it gets both a frame slot and a context slot when
     // captured.
     if (GetSavedArgumentsDescriptorVar() != NULL) {
       num_params += 1;
     }
     first_parameter_index_ = kFirstLocalSlotIndex;
     first_stack_local_index_ = first_parameter_index_ - num_params;
     num_copied_params_ = num_params;
-    if (is_native_instance_closure) {
-      num_copied_params_ += 1;
-      first_parameter_index_ -= 1;
-      first_stack_local_index_ -= 1;
-    }
   }
 
   // Allocate parameters and local variables, either in the local frame or
   // in the context(s).
   LocalScope* context_owner = NULL;  // No context needed yet.
   int next_free_frame_index =
       scope->AllocateVariables(first_parameter_index_,
                                num_params,
                                first_stack_local_index_,
                                scope,
@@ skipping 967 matching lines @@
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const AbstractType& result_type =
           AbstractType::Handle(parameter.type->raw());
 
       // Finish parsing the function type parameter.
       ParamList func_params;
+
+      // Add implicit closure object parameter.
+      func_params.AddFinalParameter(
+          TokenPos(),
+          &String::ZoneHandle(Symbols::ClosureParameter()),
+          &Type::ZoneHandle(Type::DynamicType()));
+
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         /* is_abstract = */ false,
@@ skipping 1090 matching lines @@
   if (func.IsConstructor()) {
     SequenceNode* statements = ParseConstructor(func, default_parameter_values);
     innermost_function_ = saved_innermost_function.raw();
     return statements;
   }
 
   ASSERT(!func.IsConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
-  // Static functions do not have a receiver.
-  // An instance closure may capture and access the receiver, but via the
-  // context and not via the first formal parameter.
-  // The first parameter of a factory is the AbstractTypeArguments vector of
-  // the type of the instance to be allocated.
-  if (!func.is_static() && !func.IsClosureFunction()) {
+  // An instance closure function may capture and access the receiver, but via
+  // the context and not via the first formal parameter.
+  if (func.IsClosureFunction()) {
+    // The first parameter of a closure function is the closure object.
+    ASSERT(!func.is_const());  // Closure functions cannot be const.
+    params.AddFinalParameter(
+        TokenPos(),
+        &String::ZoneHandle(Symbols::ClosureParameter()),
+        &Type::ZoneHandle(Type::DynamicType()));
+  } else if (!func.is_static()) {
+    // Static functions do not have a receiver.
     ASSERT(current_class().raw() == func.Owner());
     params.AddReceiver(ReceiverType(TokenPos()));
   } else if (func.IsFactory()) {
+    // The first parameter of a factory is the AbstractTypeArguments vector of
+    // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
   if (!func.IsGetterFunction()) {
     ParseFormalParameterList(allow_explicit_default_values, &params);
   } else {
@@ skipping 1128 matching lines @@
   if (!result_type.IsNull()) {
     ResolveTypeFromClass(alias_owner,
                          ClassFinalizer::kTryResolve,
                          &result_type);
   }
   // Parse the formal parameters of the function type.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("formal parameter list expected");
   }
   ParamList func_params;
+
+  // Add implicit closure object parameter.
+  func_params.AddFinalParameter(
+      TokenPos(),
+      &String::ZoneHandle(Symbols::ClosureParameter()),
+      &Type::ZoneHandle(Type::DynamicType()));
+
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
@@ skipping 1270 matching lines @@
   }
 }
 
 
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   func.set_is_native(true);
   TRACE_PARSER("ParseNativeFunctionBlock");
   const Class& cls = Class::Handle(func.Owner());
-  const int num_parameters = params->parameters->length();
-  const bool is_instance_closure = func.IsImplicitInstanceClosureFunction();
-  int num_params_for_resolution = num_parameters;
+  ASSERT(func.NumParameters() == params->parameters->length());
 
   // Parse the function name out.
   const intptr_t native_pos = TokenPos();
   const String& native_name = ParseNativeDeclaration();
 
-  if (is_instance_closure) {
-    num_params_for_resolution += 1;  // account for 'this' when resolving.
-  }
   // Now resolve the native function to the corresponding native entrypoint.
+  const int num_params = NativeArguments::ParameterCountForResolution(func);
   NativeFunction native_function = NativeEntry::ResolveNative(
-      cls, native_name, num_params_for_resolution);
+      cls, native_name, num_params);
   if (native_function == NULL) {
     ErrorMsg(native_pos, "native function '%s' cannot be found",
         native_name.ToCString());
   }
 
-  const bool has_opt_params = (params->num_optional_parameters > 0);
-
   // Now add the NativeBodyNode and return statement.
   current_block_->statements->Add(
-      new ReturnNode(TokenPos(), new NativeBodyNode(TokenPos(),
-                                                    native_name,
-                                                    native_function,
-                                                    num_parameters,
-                                                    has_opt_params,
-                                                    is_instance_closure)));
+      new ReturnNode(TokenPos(),
+                     new NativeBodyNode(TokenPos(),
+                                        Function::ZoneHandle(func.raw()),
+                                        native_name,
+                                        native_function)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
   const String& this_name = String::Handle(Symbols::This());
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
@@ skipping 5183 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart