Re-land r5529.

frog/leg/universe.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.
 
 class Universe {
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
@@ skipping 102 matching lines @@
     }
   }
 
   /**
    * Returns [:true:] if the selector and the [element] match; [:false:]
    * otherwise.
    */
   bool addSendArgumentsToList(Send send,
                               List list,
                               FunctionParameters parameters,
-                              visitArgument(Node argument),
-                              visitConstant(Element element)) {
+                              compileArgument(Node argument),
+                              compileConstant(Element element)) {
     void addMatchingSendArgumentsToList(Link<Node> link) {
       for (; !link.isEmpty(); link = link.tail) {
-        list.add(visitArgument(link.head));
+        list.add(compileArgument(link.head));
       }
     }
 
     if (!this.applies(parameters)) return false;
     if (this.positionalArgumentCount == parameters.parameterCount) {
       addMatchingSendArgumentsToList(send.arguments);
       return true;
     }
 
     // If there are named arguments, provide them in the order
     // expected by the called function, which is the source order.
 
     // Visit positional arguments and add them to the list.
     Link<Node> arguments = send.arguments;
     int positionalArgumentCount = this.positionalArgumentCount;
     for (int i = 0;
          i < positionalArgumentCount;
          arguments = arguments.tail, i++) {
-      list.add(visitArgument(arguments.head));
+      list.add(compileArgument(arguments.head));
     }
 
     // Visit named arguments and add them into a temporary list.
     List namedArguments = [];
     for (; !arguments.isEmpty(); arguments = arguments.tail) {
-      namedArguments.add(visitArgument(arguments.head));
+      NamedArgument namedArgument = arguments.head;
+      namedArguments.add(compileArgument(namedArgument.expression));
     }
 
     Link<Element> remainingNamedParameters = parameters.optionalParameters;
     // Skip the optional parameters that have been given in the
     // positional arguments.
     for (int i = parameters.requiredParameterCount;
          i < positionalArgumentCount;
          i++) {
       remainingNamedParameters = remainingNamedParameters.tail;
     }
 
     // Loop over the remaining named parameters, and try to find
     // their values: either in the temporary list or using the
     // default value.
     for (;
          !remainingNamedParameters.isEmpty();
          remainingNamedParameters = remainingNamedParameters.tail) {
       Element parameter = remainingNamedParameters.head;
       int foundIndex = -1;
       for (int i = 0; i < this.namedArguments.length; i++) {
         SourceString name = this.namedArguments[i];
         if (name == parameter.name) {
           foundIndex = i;
           break;
         }
       }
       if (foundIndex != -1) {
         list.add(namedArguments[foundIndex]);
       } else {
-        list.add(visitConstant(parameter)); 
+        list.add(compileConstant(parameter)); 
       }
     }
     return true;
   }
 
   static bool sameNames(List<SourceString> first, List<SourceString> second) {
     for (int i = 0; i < first.length; i++) {
       if (first[i] != second[i]) return false;
     }
     return true;
@@ skipping 29 matching lines @@
     if (!orderedNamedArguments.isEmpty()) return orderedNamedArguments;
 
     List<SourceString> list = new List<SourceString>.from(namedArguments);
     list.sort((SourceString first, SourceString second) {
       return first.slowToString().compareTo(second.slowToString());
     });
     orderedNamedArguments = list;
     return orderedNamedArguments;
   }
 }