Fix Function.apply for static functions in new emitter.

pkg/compiler/lib/src/js_emitter/new_emitter/model_emitter.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.new_js_emitter.model_emitter;
 
 import '../../constants/values.dart' show ConstantValue;
 import '../../dart2jslib.dart' show Compiler;
 import '../../dart_types.dart' show DartType;
 import '../../elements/elements.dart' show ClassElement;
@@ skipping 97 matching lines @@
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
 
     js.Expression code = new js.ArrayInitializer(elements);
 
     Map<String, dynamic> holes =
       {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
        'holders': emitHolders(program.holders),
        'tearOff': buildTearOffCode(backend),
        'parseFunctionDescriptor':
            js.js.statement(parseFunctionDescriptorBoilerplate,
-               {'argCnt': js.string(namer.requiredParameterField),
-                'defArgValues': js.string(namer.defaultValuesField),
+               {'argumentCount': js.string(namer.requiredParameterField),
+                'defaultArgumentValues': js.string(namer.defaultValuesField),
                 'callName': js.string(namer.callNameField)}),
 
        'cyclicThrow':
            backend.emitter.staticFunctionAccess(backend.getCyclicThrowHelper()),
        'outputContainsConstantList': program.outputContainsConstantList,
        'embeddedGlobals': emitEmbeddedGlobals(program),
        'constants': emitConstants(fragment.constants),
        'staticNonFinals':
             emitStaticNonFinalFields(fragment.staticNonFinalFields),
        'operatorIsPrefix': js.string(namer.operatorIsPrefix),
        'callName': js.string(namer.callNameField),
+       'argumentCount': js.string(namer.requiredParameterField),
+       'defaultArgumentValues': js.string(namer.defaultValuesField),
        'eagerClasses': emitEagerClassInitializations(fragment.libraries),
        'invokeMain': fragment.invokeMain,
        'code': code};
 
     holes.addAll(nativeHoles(program));
 
     return js.js.statement(boilerplate, holes);
   }
 
   Map<String, dynamic> nativeHoles(Program program) {
@@ skipping 471 matching lines @@
       var stub = descriptor[pos + 2];
       stub[#callName] = descriptor[pos + 1];
       proto[descriptor[pos]] = stub;
       funs.push(stub);
     }
 
     if (tearOffName) {
       proto[tearOffName] =
           tearOff(funs, reflectionInfo, false, name, isIntercepted);
     }
-    if (descriptor[pos] != null) {
-      f[#argCnt] = descriptor[pos];
-      f[#defArgValues] = descriptor[pos + 1];
+    if (pos < descriptor.length) {
+      f[#argumentCount] = descriptor[pos];
+      f[#defaultArgumentValues] = descriptor[pos + 1];
     }
   } else {
     proto[name] = descriptor;
   }
 }
 """;
 
   js.Expression _generateFunctionType(DartType memberType) {
     if (memberType.containsTypeVariables) {
       js.Expression thisAccess = js.js(r'this.$receiver');
@@ skipping 189 matching lines @@
       };
     } else {
       // Parse the tear off information and generate compile handlers.
       // TODO(herhut): Share parser with instance methods.      
       function compileAllStubs() {
         var funs;
         var fun = compile(name, descriptor[0]);
         fun[#callName] = descriptor[1];
         holder[name] = fun;
         funs = [fun];
-        for (var pos = 4; pos < descriptor.length; pos += 3) {
+        // We iterate in blocks of 3 but have to stop before we reach the
+        // (optional) two trailing items. To accomplish this, we only iterate
+        // until we reach length - 2.
+        for (var pos = 4; pos < descriptor.length - 2; pos += 3) {
           var stubName = descriptor[pos];
           fun = compile(stubName, descriptor[pos + 2]);
           fun[#callName] = descriptor[pos + 1];
           holder[stubName] = fun;
           funs.push(fun);
         }
         if (descriptor[2] != null) {  // tear-off name.
           // functions, reflectionInfo, isStatic, name, isIntercepted.
           holder[descriptor[2]] = 
               tearOff(funs, descriptor[3], true, name, false);
         }
+        if (pos < descriptor.length) {
+          fun[#argumentCount] = descriptor[pos];
+          fun[#defaultArgumentValues] = descriptor[pos + 1];
+        }
       }
 
       function setupCompileAllAndDelegateStub(name) {
         holder[name] = function() {
           compileAllStubs();
           return holder[name].apply(this, arguments);
         };
       }
 
       setupCompileAllAndDelegateStub(name);
@@ skipping 164 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }