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),
+                '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),
        '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 410 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).
-  /// [Method.code]
-  /// [DartMethod.callName]
-  /// isInterceptedMethod (optional, present if [DartMethod.needsTearOff]).
-  /// [DartMethod.tearOffName] (optional, present if [DartMethod.needsTearOff]).
-  /// functionType (optional, present if [DartMethod.needsTearOff]).
+  /// * [InstanceMethod.aliasName] (optional).
+  /// * [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]
+  /// * [ParameterStubMethod.name]
+  /// * [ParameterStubMethod.callName]
+  /// * [ParameterStubMethod.code]
   ///
   /// for each stub in [DartMethod.parameterStubs].
+  ///
+  /// If the closure could be used in `Function.apply` (i.e.
+  /// [DartMethod.canBeApplied] is true) then the following fields are appended:
+  ///
+  /// * [DartMethod.requiredParameterCount]
+  /// * [DartMethod.optionalParameterDefaultValues]
 
   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];
+    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) {
+    // 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 (++pos; pos < descriptor.length - 2; pos += 3) {
       var stub = descriptor[pos + 2];
-      stub.$callName = descriptor[pos + 1];
+      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];
+    }
   } 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 67 matching lines @@
         var method = compile(name, descriptor);
         holder[name] = method;
         return method.apply(this, arguments);
       };
     } 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];
+        fun[#callName] = descriptor[1];
         holder[name] = fun;
         funs = [fun];
         for (var pos = 4; pos < descriptor.length; pos += 3) {
           var stubName = descriptor[pos];
           fun = compile(stubName, descriptor[pos + 2]);
-          fun.\$callName = descriptor[pos + 1];
+          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);
         }
       }
 
@@ skipping 176 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }