Cleanups based on Kevin's and Florian's suggestions.

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 665 matching lines @@
   ASSERT(param_name.IsSymbol());
   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();
     for (intptr_t i = 0; i < num_named_args; i++) {
-      if (arg_desc.NameAt(i) == param_name.raw()) {
+      if (arg_desc.MatchesNameAt(i, param_name)) {
         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 88 matching lines @@
   arguments.SetReturn(target_code);
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
 // function cache of the receiver's class and returns the compiled code or null.
 // Only the number of named arguments is checked, but not the actual names.
 RawCode* ResolveCompileInstanceCallTarget(
     const Instance& receiver,
     const ICData& ic_data,
-    const ArgumentsDescriptor& arguments_descriptor) {
+    const Array& arguments_descriptor_array) {
+  ArgumentsDescriptor arguments_descriptor(arguments_descriptor_array);
   intptr_t num_arguments = arguments_descriptor.Count();
   int num_named_arguments = arguments_descriptor.NamedCount();
   String& function_name = String::Handle(ic_data.target_name());
   ASSERT(function_name.IsSymbol());
 
   Function& function = Function::Handle();
   function = Resolver::ResolveDynamic(receiver,
                                       function_name,
                                       num_arguments,
                                       num_named_arguments);
@@ skipping 61 matching lines @@
   ASSERT(arguments.ArgCount() ==
      kBreakpointDynamicHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
 }
 
 
 static RawFunction* InlineCacheMissHandler(
     const GrowableArray<const Instance*>& args,
     const ICData& ic_data,
-    const ArgumentsDescriptor& arg_descriptor) {
+    const Array& arg_descriptor_array) {
   const Instance& receiver = *args[0];
   const Code& target_code =
       Code::Handle(ResolveCompileInstanceCallTarget(receiver,
                                                     ic_data,
-                                                    arg_descriptor));
+                                                    arg_descriptor_array));
   if (target_code.IsNull()) {
     // Let the megamorphic stub handle special cases: NoSuchMethod,
     // closure calls.
     if (FLAG_trace_ic) {
       OS::Print("InlineCacheMissHandler NULL code for receiver: %s\n",
           receiver.ToCString());
     }
     return Function::null();
   }
   const Function& target_function =
@@ skipping 40 matching lines @@
 //   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));
   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));
+      Function::Handle(InlineCacheMissHandler(args, ic_data, arg_desc_array));
   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));
   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));
+      Function::Handle(InlineCacheMissHandler(args, ic_data, arg_desc_array));
   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));
   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));
+      Function::Handle(InlineCacheMissHandler(args, ic_data, arg_desc_array));
   arguments.SetReturn(result);
 }
 
 
 // Updates IC data for two arguments. Used by the equality operation when
 // the control flow bypasses regular inline cache (null arguments).
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: Target's name.
 //   Arg3: ICData.
@@ skipping 859 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