Implement named arguments in InstanceMirror.invoke.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart

 // 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.
 
 part of js_backend;
 
 /// Enables debugging of fast/slow objects using V8-specific primitives.
 const DEBUG_FAST_OBJECTS = false;
 
 /**
@@ skipping 1247 matching lines @@
       if (backend.isInterceptedMethod(member)) {
         interceptorInvocationNames.add(name);
       }
       code = extendWithMetadata(member, code);
       builder.addProperty(name, code);
       String reflectionName = getReflectionName(member, name);
       if (reflectionName != null) {
         var reflectable =
             js(backend.isAccessibleByReflection(member) ? '1' : '0');
         builder.addProperty('+$reflectionName', reflectable);
+        jsAst.Node defaultValues = reifyDefaultArguments(member);
+        if (defaultValues != null) {
+          String unmangledName = member.name.slowToString();
+          builder.addProperty('*$unmangledName', defaultValues);
+        }
       }
       code = backend.generatedBailoutCode[member];
       if (code != null) {
         builder.addProperty(namer.getBailoutName(member), code);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty) {
-        addParameterStubs(member, builder.addProperty);
+        addParameterStubs(function, builder.addProperty);
       }
     } else if (!member.isField()) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, builder);
   }
 
   /// Returns the "reflection name" of an [Element] or [Selector].
   /// The reflection name of a getter 'foo' is 'foo'.
@@ skipping 82 matching lines @@
     } else if (element.isClass()) {
       ClassElement cls = element;
       if (cls.isUnnamedMixinApplication) return null;
       return cls.name.slowToString();
     }
     throw compiler.internalErrorOnElement(
         element, 'Do not know how to reflect on this $element');
   }
 
   String namedParametersAsReflectionNames(Selector selector) {
-    if (selector.orderedNamedArguments.isEmpty) return '';
-    String names =
-        selector.orderedNamedArguments.map((x) => x.slowToString()).join(':');
+    if (selector.getOrderedNamedArguments().isEmpty) return '';
+    String names = selector.getOrderedNamedArguments().map(
+        (x) => x.slowToString()).join(':');
     return ':$names';
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(ClassElement classElement,
                            ClassBuilder builder) {
@@ skipping 984 matching lines @@
     for (Element element in Elements.sortedByPosition(elements)) {
       CodeBuffer buffer = bufferForElement(element, eagerBuffer);
       jsAst.Expression code = backend.generatedCode[element];
       String name = namer.getNameOfGlobalFunction(element);
       code = extendWithMetadata(element, code);
       emitStaticFunction(buffer, name, code);
       String reflectionName = getReflectionName(element, name);
       if (reflectionName != null) {
         var reflectable = backend.isAccessibleByReflection(element) ? 1 : 0;
         buffer.write(',$n$n"+$reflectionName":${_}$reflectable');
+        jsAst.Node defaultValues = reifyDefaultArguments(element);
+        if (defaultValues != null) {
+          String unmangledName = element.name.slowToString();
+          buffer.write(',$n$n"*$unmangledName":${_}');
+          buffer.write(jsAst.prettyPrint(defaultValues, compiler));
+        }
       }
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
         emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
       }
     }
 
     if (!pendingElementsWithBailouts.isEmpty) {
       addComment('pendingElementsWithBailouts', eagerBuffer);
@@ skipping 1292 matching lines @@
             metadata.add(constantReference(value));
           }
         }
       }
       if (metadata.isEmpty) return null;
       return js.fun(
           [], [js.return_(new jsAst.ArrayInitializer.from(metadata))]);
     });
   }
 
+  jsAst.Node reifyDefaultArguments(FunctionElement function) {
+    FunctionSignature signature = function.computeSignature(compiler);
+    if (signature.optionalParameterCount == 0) return null;
+    List<int> defaultValues = <int>[];
+    for (Element element in signature.orderedOptionalParameters) {
+      Constant value =
+          compiler.constantHandler.initialVariableValues[element];
+      String stringRepresentation = (value == null) ? "null"
+          : jsAst.prettyPrint(constantReference(value), compiler).getText();
+      defaultValues.add(addGlobalMetadata(stringRepresentation));
+    }
+    return js.toExpression(defaultValues);
+  }
+
   int reifyMetadata(MetadataAnnotation annotation) {
     Constant value = annotation.value;
     if (value == null) {
       compiler.reportInternalError(
           annotation, 'Internal error: value is null');
       return -1;
     }
     return addGlobalMetadata(
         jsAst.prettyPrint(constantReference(value), compiler).getText());
   }
@@ skipping 552 matching lines @@
   void warnNotImplemented(Element element, String message) {
     compiler.reportMessage(compiler.spanFromSpannable(element),
                            MessageKind.GENERIC.error({'text': message}),
                            api.Diagnostic.WARNING);
   }
 
   // TODO(ahe): This code should be integrated in finishClasses.
   String getReflectionDataParser() {
     String metadataField = '"${namer.metadataField}"';
     String reflectableField = namer.reflectableField;
+    String defaultValuesField = namer.defaultValuesField;
+    String methodsWithOptionalArgumentsField =
+        namer.methodsWithOptionalArgumentsField;
     return '''
 (function (reflectionData) {
 '''
 // [map] returns an object literal that V8 shouldn't try to optimize with a
 // hidden class. This prevents a potential performance problem where V8 tries
 // to build a hidden class for an object used as a hashMap.
 '''
   function map(x){x={x:x};delete x.x;return x}
   if (!init.libraries) init.libraries = [];
   if (!init.mangledNames) init.mangledNames = map();
@@ skipping 38 matching lines @@
         var previousProperty;
         if (firstChar === "+") {
           mangledGlobalNames[previousProperty] = property.substring(1);
           if (descriptor[property] == 1) ''' // Break long line.
 '''descriptor[previousProperty].$reflectableField = 1;
           if (element && element.length) ''' // Break long line.
 '''init.interfaces[previousProperty] = element;
         } else if (firstChar === "@") {
           property = property.substring(1);
           ${namer.CURRENT_ISOLATE}[property][$metadataField] = element;
+        } else if (firstChar === "*") {
+          globalObject[previousProperty].$defaultValuesField = element;
+          var optionalMethods = descriptor.$methodsWithOptionalArgumentsField;
+          if (!optionalMethods) {
+            descriptor.$methodsWithOptionalArgumentsField = optionalMethods = {}
+          }
+          optionalMethods[property] = previousProperty;
         } else if (typeof element === "function") {
           globalObject[previousProperty = property] = element;
           functions.push(property);
           init.globalFunctions[property] = element;
         } else {
           previousProperty = property;
           var newDesc = {};
           var previousProp;
           for (var prop in element) {
             if (!hasOwnProperty.call(element, prop)) continue;
             firstChar = prop.substring(0, 1);
             if (prop === "static") {
               processStatics(init.statics[property] = element[prop]);
             } else if (firstChar === "+") {
               mangledNames[previousProp] = prop.substring(1);
               if (element[prop] == 1) ''' // Break long line.
 '''element[previousProp].$reflectableField = 1;
             } else if (firstChar === "@" && prop !== "@") {
               newDesc[prop.substring(1)][$metadataField] = element[prop];
+            } else if (firstChar === "*") {
+              newDesc[previousProp].$defaultValuesField = element[prop];
+              var optionalMethods = newDesc.$methodsWithOptionalArgumentsField;
+              if (!optionalMethods) {
+                newDesc.$methodsWithOptionalArgumentsField = optionalMethods={}
+              }
+              optionalMethods[prop] = previousProp;
             } else {
               newDesc[previousProp = prop] = element[prop];
             }
           }
           $classesCollector[property] = [globalObject, newDesc];
           classes.push(property);
         }
       }
     }
     processStatics(descriptor);
@@ skipping 10 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;