Fix bug in the inliner when dealing with named optional parameters.

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, 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/flow_graph_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 532 matching lines @@
       // Create a parameter stub for each fixed positional parameter.
       for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) {
         param_stubs->Add(CreateParameterStub(i, (*arguments)[i], callee_graph));
       }
 
       // If the callee has optional parameters, rebuild the argument and stub
       // arrays so that actual arguments are in one-to-one with the formal
       // parameters.
       if (function.HasOptionalParameters()) {
         TRACE_INLINING(OS::Print("     adjusting for optional parameters\n"));
-        AdjustForOptionalParameters(*parsed_function,
-                                    argument_names,
-                                    arguments,
-                                    param_stubs,
-                                    callee_graph);
+        if (!AdjustForOptionalParameters(*parsed_function,
+                                         argument_names,
+                                         arguments,
+                                         param_stubs,
+                                         callee_graph)) {
+          function.set_is_inlinable(false);
+          TRACE_INLINING(OS::Print("     Bailout: optional arg mismatch\n"));
+          return false;
+        }
       }
 
       // After treating optional parameters the actual/formal count must match.
       ASSERT(arguments->length() == function.NumParameters());
       ASSERT(param_stubs->length() == callee_graph->parameter_count());
 
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_ssa_timer,
                          isolate);
@@ skipping 254 matching lines @@
       }
       InlinedCallData call_data(call, &arguments);
       if (TryInlining(target,
                       call->instance_call()->argument_names(),
                       &call_data)) {
         InlineCall(&call_data);
       }
     }
   }
 
-  void AdjustForOptionalParameters(const ParsedFunction& parsed_function,
+  bool AdjustForOptionalParameters(const ParsedFunction& parsed_function,
                                    const Array& argument_names,
                                    GrowableArray<Value*>* arguments,
                                    ZoneGrowableArray<Definition*>* param_stubs,
                                    FlowGraph* callee_graph) {
     const Function& function = parsed_function.function();
     // The language and this code does not support both optional positional
     // and optional named parameters for the same function.
     ASSERT(!function.HasOptionalPositionalParameters() ||
            !function.HasOptionalNamedParameters());
 
@@ skipping 14 matching lines @@
       // default value.
       for (intptr_t i = arg_count; i < param_count; ++i) {
         const Object& object =
             Object::ZoneHandle(
                 parsed_function.default_parameter_values().At(
                     i - fixed_param_count));
         ConstantInstr* constant = new ConstantInstr(object);
         arguments->Add(NULL);
         param_stubs->Add(constant);
       }
-      return;
+      return true;
     }
 
     ASSERT(function.HasOptionalNamedParameters());
 
     // Passed arguments must match fixed parameters plus named arguments.
     intptr_t argument_names_count =
         (argument_names.IsNull()) ? 0 : argument_names.Length();
     ASSERT(arg_count == (fixed_param_count + argument_names_count));
 
     // Fast path when no optional named parameters are given.
     if (argument_names_count == 0) {
       for (intptr_t i = 0; i < param_count - fixed_param_count; ++i) {
         arguments->Add(NULL);
         param_stubs->Add(GetDefaultValue(i, parsed_function));
       }
-      return;
+      return true;
     }
 
     // Otherwise, build a collection of name/argument pairs.
     GrowableArray<NamedArgument> named_args(argument_names_count);
     for (intptr_t i = 0; i < argument_names.Length(); ++i) {
       String& arg_name = String::Handle(Isolate::Current());
       arg_name ^= argument_names.At(i);
       named_args.Add(
           NamedArgument(&arg_name, (*arguments)[i + fixed_param_count]));
     }
 
     // Truncate the arguments array to just fixed parameters.
     arguments->TruncateTo(fixed_param_count);
 
     // For each optional named parameter, add the actual argument or its
     // default if no argument is passed.
+    intptr_t match_count = 0;
     for (intptr_t i = fixed_param_count; i < param_count; ++i) {
       String& param_name = String::Handle(function.ParameterNameAt(i));
       // Search for and add the named argument.
       Value* arg = NULL;
       for (intptr_t j = 0; j < named_args.length(); ++j) {
         if (param_name.Equals(*named_args[j].name)) {
           arg = named_args[j].value;
+          match_count++;
           break;
         }
       }
       arguments->Add(arg);
       // Create a stub for the argument or use the parameter's default value.
       if (arg != NULL) {
         param_stubs->Add(CreateParameterStub(i, arg, callee_graph));
       } else {
         param_stubs->Add(
             GetDefaultValue(i - fixed_param_count, parsed_function));
       }
     }
+    return argument_names_count == match_count;
   }
 
 
   FlowGraph* caller_graph_;
   bool inlined_;
   intptr_t initial_size_;
   intptr_t inlined_size_;
   intptr_t inlining_depth_;
   CallSites* collected_call_sites_;
   CallSites* inlining_call_sites_;
@@ skipping 439 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart