Implement Function.apply in the 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;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer,
     ConstantEmitter;
 
 import '../js_emitter.dart' show
@@ skipping 89 matching lines @@
     elements.add(
         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),
+           js.js.statement(parseFunctionDescriptorBoilerplate,
+               {'argCnt': js.string(namer.requiredParameterField),
+                'defArgValues': js.string(namer.defaultValuesField)}),
+
        '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),
        'eagerClasses': emitEagerClassInitializations(fragment.libraries),
        'invokeMain': fragment.invokeMain,
@@ skipping 418 matching lines @@
     assert(field.isLazy);
     return unparse(compiler, field.code);
   }
 
   /// JavaScript code template that implements parsing of a function descriptor.
   /// Descriptors are used in place of the actual JavaScript function
   /// definition in the output if additional information needs to be passed to
   /// facilitate the generation of tearOffs at runtime. The format is an array
   /// with the following fields:
   ///
   /// [InstanceMethod.aliasName] (optional).

[floitsch, 2015/02/16 15:26:03]

Since this is dartdoc, writing the fields line per line doesn't work.
I guess the easiest is to make it a bulleted list.

ditto for the other two lists.

[herhut, 2015/02/17 10:25:39]

Done.

   /// [Method.code]
   /// [DartMethod.callName]
   /// isInterceptedMethod (optional, present if [DartMethod.needsTearOff]).
   /// [DartMethod.tearOffName] (optional, present if [DartMethod.needsTearOff]).
   /// functionType (optional, present if [DartMethod.needsTearOff]).
   ///
   /// followed by
   ///
   /// [ParameterStubMethod.name]
   /// [ParameterStubMethod.code]

[floitsch, 2015/02/16 15:26:03]

Something seems to be missing here.

[herhut, 2015/02/17 10:25:39]

[ParameterStubMethod.callName] was missing. Fixed.

   ///
-  /// for each stub in [DartMethod.parameterStubs].
+  /// for each stub in [DartMethod.parameterStubs]. If [DartMethod.canBeApplied]

[floitsch, 2015/02/16 15:26:03]

Start a new paragraph.

If the closure could be used in `Function.apply` ([DartMethod.canBeApplied] is
true) then the following fields are appended:

[herhut, 2015/02/17 10:25:39]

Done.

+  /// is true
+  ///
+  /// [DartMethod.requiredParameterCount]
+  /// [DartMethod.optionalParameterDefaultValues]
+  ///
+  /// is also appended.
 
   static final String parseFunctionDescriptorBoilerplate = r"""
 function parseFunctionDescriptor(proto, name, descriptor) {
   if (descriptor instanceof Array) {
     // 'pos' points to the last read entry.
     var f, pos = -1;
     var aliasOrFunction = descriptor[++pos];
     if (typeof aliasOrFunction == "string") {
       // Install the alias for super calls on the prototype chain.
       proto[aliasOrFunction] = f = descriptor[++pos];
     } else {
       f = aliasOrFunction;
     }
 
     proto[name] = f;
     var funs = [f];
     f.$callName = descriptor[++pos];
 
     var isInterceptedOrParameterStubName = descriptor[pos + 1];
     var isIntercepted, tearOffName, reflectionInfo;
     if (typeof isInterceptedOrParameterStubName == "boolean") {
       isIntercepted = descriptor[++pos];
       tearOffName = descriptor[++pos];
       reflectionInfo = descriptor[++pos];
     }
 
-    for (++pos; pos < descriptor.length; pos += 3) {
+    for (++pos; pos < descriptor.length - 2; pos += 3) {

[floitsch, 2015/02/16 15:26:03]

add a comment why the "2".

[herhut, 2015/02/17 10:25:39]

Done.

       var stub = descriptor[pos + 2];
       stub.$callName = descriptor[pos + 1];

[floitsch, 2015/02/16 15:26:03]

This should be a shared variable. (the "$callName").

[herhut, 2015/02/17 10:25:39]

Done.

       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];
+    }
   } else {
     proto[name] = descriptor;
   }
 }
 """;
 
   js.Expression _generateFunctionType(DartType memberType) {
     if (memberType.containsTypeVariables) {
       js.Expression thisAccess = js.js(r'this.$receiver');
       return backend.rti.getSignatureEncoding(memberType, thisAccess);
     } else {
       return js.number(backend.emitter.metadataCollector.reifyType(memberType));
     }
   }
 
+  js.Expression _encodeOptionalParameterDefaultValues(DartMethod method) {
+    js.Expression result;
+    // TODO(herhut): Replace [js.LiteralNull] with [js.ArrayHole].
+    if (method.optionalParameterDefaultValues is List) {
+      List<ConstantValue> defs = method.optionalParameterDefaultValues;
+      Iterable<js.Expression> elements = defs.map(constantEmitter.reference);
+      return new js.ArrayInitializer(elements.toList());
+    } else {
+      Map<String, ConstantValue> defs = method.optionalParameterDefaultValues;
+      List<js.Property> properties = <js.Property>[];
+      defs.forEach((String name, ConstantValue value) {
+        properties.add(new js.Property(js.string(name),
+            constantEmitter.reference(value)));
+      });
+      return new js.ObjectInitializer(properties);
+    }
+  }
+
   Iterable<js.Expression> emitInstanceMethod(Method method) {
 
     List<js.Expression> makeNameCodePair(Method method) {
       return [js.string(method.name), method.code];
     }
 
     List<js.Expression> makeNameCallNameCodeTriplet(ParameterStubMethod stub) {
       js.Expression callName = stub.callName == null
           ? new js.LiteralNull()
           : js.string(stub.callName);
@@ skipping 14 matching lines @@
         data.add(js.string(method.callName));
 
         if (method.needsTearOff) {
           bool isIntercepted = backend.isInterceptedMethod(method.element);
           data.add(new js.LiteralBool(isIntercepted));
           data.add(js.string(method.tearOffName));
           data.add(_generateFunctionType(method.type));
         }
 
         data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
+        if (method.canBeApplied) {
+          data.add(js.number(method.requiredParameterCount));
+          data.add(_encodeOptionalParameterDefaultValues(method));
+        }
         return [js.string(method.name), new js.ArrayInitializer(data)];
       } else {
         // TODO(floitsch): not the most efficient way...
         return ([method]..addAll(method.parameterStubs))
             .expand(makeNameCodePair);
       }
     } else {
       return makeNameCodePair(method);
     }
   }
@@ skipping 23 matching lines @@
         /// The format emitted is the same as for the parser specified at
         /// [parseFunctionDescriptorBoilerplate] except for the missing
         /// field whether the method is intercepted.
         // [name, [function, callName, tearOffName, functionType,
         //     stub1_name, stub1_callName, stub1_code, ...]
         var data = [unparse(compiler, method.code)];
         data.add(js.string(method.callName));
         data.add(js.string(method.tearOffName));
         data.add(_generateFunctionType(method.type));
         data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
+        if (method.canBeApplied) {
+          data.add(js.number(method.requiredParameterCount));
+          data.add(_encodeOptionalParameterDefaultValues(method));
+        }
         return [js.string(method.name), holderIndex,
                 new js.ArrayInitializer(data)];
       } else {
         method.parameterStubs.forEach(_addMethod);
       }
     }
     return output;
   }
 
   static final String setupProgramName = "setupProgram";
@@ skipping 270 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }