Allow implicit 'close your eyes' of native methods. This will hopefully fix issue 3466.

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 125 matching lines @@
   }
   node_sequence_->set_last_parameter_id(parameter_id);
 }
 
 
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   const int fixed_parameter_count = function().num_fixed_parameters();
   const int optional_parameter_count = function().num_optional_parameters();
   const int parameter_count = fixed_parameter_count + optional_parameter_count;
+  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 (optional_parameter_count == 0) {
+  if (optional_parameter_count == 0 && !is_native_instance_closure) {
     // Parameter i will be at fp[1 + parameter_count - i] and local variable
     // j will be at fp[kFirstLocalSlotIndex - j].
     first_parameter_index_ = 1 + parameter_count;
     first_stack_local_index_ = kFirstLocalSlotIndex;
     copied_parameter_count_ = 0;
   } else {
     // Parameter i will be at fp[kFirstLocalSlotIndex - i] and local variable
     // j will be at fp[kFirstLocalSlotIndex - parameter_count - j].
     first_parameter_index_ = kFirstLocalSlotIndex;
     first_stack_local_index_ = first_parameter_index_ - parameter_count;
     copied_parameter_count_ = parameter_count;
+    if (is_native_instance_closure) {
+      copied_parameter_count_ += 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_,
                                parameter_count,
                                first_stack_local_index_,
                                scope,
@@ skipping 3777 matching lines @@
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
   }
 }
 
 
 // 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;
 
   // Parse the function name out.
   const intptr_t native_pos = token_index_;
   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.
-  NativeFunction native_function = NativeEntry::ResolveNative(cls,
-                                                              native_name,
-                                                              num_parameters);
+  NativeFunction native_function = NativeEntry::ResolveNative(
+      cls, native_name, num_params_for_resolution);
   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(token_index_, new NativeBodyNode(token_index_,
                                                       native_name,
                                                       native_function,
                                                       num_parameters,
-                                                      has_opt_params)));
+                                                      has_opt_params,
+                                                      is_instance_closure)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope,
                                       bool test_only) {
   const String& this_name = String::Handle(String::NewSymbol(kThisName));
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
@@ skipping 4594 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart