Pass handles not raw objects into methods.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 656 matching lines @@
 // Arg0: formal parameter index as Smi.
 // Arg1: formal parameter name as Symbol.
 // Arg2: arguments descriptor array.
 // Return value: true or false.
 DEFINE_RUNTIME_ENTRY(ArgumentDefinitionTest, 3) {
   ASSERT(arguments.ArgCount() ==
          kArgumentDefinitionTestRuntimeEntry.argument_count());
   const Smi& param_index = Smi::CheckedHandle(arguments.ArgAt(0));
   const String& param_name = String::CheckedHandle(arguments.ArgAt(1));
   ASSERT(param_name.IsSymbol());
-  ArgumentsDescriptor arg_desc(arguments.ArgAt(2));
+  const Array& arg_desc_array = Array::CheckedHandle(arguments.ArgAt(2));
+  ArgumentsDescriptor arg_desc(arg_desc_array);
   const intptr_t num_pos_args = arg_desc.PositionalCount();
   // Check if the formal parameter is defined by a positional argument.
   bool is_defined = num_pos_args > param_index.Value();
   if (!is_defined) {
     // Check if the formal parameter is defined by a named argument.
     const intptr_t num_named_args = arg_desc.NamedCount();
-    String& arg_name = String::Handle();
     for (intptr_t i = 0; i < num_named_args; i++) {
-      arg_name ^= arg_desc.NameAt(i);
-      if (arg_name.raw() == param_name.raw()) {
+      if (arg_desc.NameAt(i) == param_name.raw()) {
         is_defined = true;
         break;
       }
     }
   }
   arguments.SetReturn(Bool::Handle(Bool::Get(is_defined)));
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
@@ skipping 135 matching lines @@
 //   Arg2: Arguments descriptor array.
 //   Returns: RawCode object or NULL (method not found or not compileable).
 // This is called by the megamorphic stub when instance call does not need to be
 // patched.
 // Used by megamorphic lookup/no-such-method-handling.
 DEFINE_RUNTIME_ENTRY(ResolveCompileInstanceFunction, 3) {
   ASSERT(arguments.ArgCount() ==
          kResolveCompileInstanceFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
-  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(2));
+  const Array& arg_desc_array = Array::CheckedHandle(arguments.ArgAt(2));
+  ArgumentsDescriptor arg_descriptor(arg_desc_array);

[Kevin Millikin (Google), 2012/12/06 10:36:28]

I was trying to avoid this API, which I still think is unnecessary.

Since we have to have it, we should pass the Array handle in to
ResolveCompileInstanceCallTarget, and construct the ArgumentsDescriptor there,
rather than requiring all callers to create one.

   const Code& code =
       Code::Handle(ResolveCompileInstanceCallTarget(receiver,
                                                     ic_data,
                                                     arg_descriptor));
   arguments.SetReturn(code);
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint.
 DEFINE_RUNTIME_ENTRY(BreakpointStaticHandler, 0) {
@@ skipping 101 matching lines @@
 //   Arg0: Receiver object.
 //   Arg1: IC data object.
 //   Arg2: Arguments descriptor array.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerOneArg, 3) {
   ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerOneArgRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
-  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(2));
+  const Array& arg_desc_array = Array::CheckedHandle(arguments.ArgAt(2));
+  ArgumentsDescriptor arg_descriptor(arg_desc_array);
   GrowableArray<const Instance*> args(1);
   args.Add(&receiver);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(args, ic_data, arg_descriptor));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: IC data object.
 //   Arg3: Arguments descriptor array.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerTwoArgs, 4) {
   ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerTwoArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& other = Instance::CheckedHandle(arguments.ArgAt(1));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(2));
-  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(3));
+  const Array& arg_desc_array = Array::CheckedHandle(arguments.ArgAt(3));
+  ArgumentsDescriptor arg_descriptor(arg_desc_array);
   GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&other);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(args, ic_data, arg_descriptor));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: Second argument after receiver.
 //   Arg3: IC data object.
 //   Arg4: Arguments descriptor array.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerThreeArgs, 5) {
   ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerThreeArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const Instance& arg2 = Instance::CheckedHandle(arguments.ArgAt(2));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(3));
-  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(4));
+  const Array& arg_desc_array = Array::CheckedHandle(arguments.ArgAt(4));
+  ArgumentsDescriptor arg_descriptor(arg_desc_array);
   GrowableArray<const Instance*> args(3);
   args.Add(&receiver);
   args.Add(&arg1);
   args.Add(&arg2);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(args, ic_data, arg_descriptor));
   arguments.SetReturn(result);
 }
 
 
@@ skipping 865 matching lines @@
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   const Bigint& big_left = Bigint::Handle(left);
   const Bigint& big_right = Bigint::Handle(right);
   return BigintOperations::Compare(big_left, big_right);
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart