Use ConstExp for storing constants.

sdk/lib/_internal/compiler/implementation/universe/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.
 
 library universe;
 
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
@@ skipping 377 matching lines @@
            name == element.name ||
            name == 'assert' && world.isAssertMethod(element);
   }
 
   bool applies(Element element, World world) {
     if (!sameNameHack(element, world)) return false;
     return appliesUnnamed(element, world);
   }
 
   /**
-   * Fills [list] with the arguments in a defined order.
+   * Fills [list] with the arguments in the normalized order.
    *
    * [compileArgument] is a function that returns a compiled version
    * of an argument located in [arguments].
    *
-   * [compileConstant] is a function that returns a compiled constant
+   * [compileDefaultValue] is a function that returns a compiled constant
    * of an optional argument that is not in [arguments].
    *
    * Returns [:true:] if the selector and the [element] match; [:false:]
    * otherwise.
    *
    * Invariant: [element] must be the implementation element.
    */
-  bool addArgumentsToList(Link<Node> arguments,
-                          List list,
-                          FunctionElement element,
-                          compileArgument(Node argument),
-                          compileConstant(Element element),
-                          World world) {
+  /*<T>*/ bool addArgumentsToList(
+      Link<Node> arguments,
+      List/*<T>*/ list,
+      FunctionElement element,
+      /*T*/ compileArgument(Node argument),
+      /*T*/ compileDefaultValue(ParameterElement element),
+      World world) {
     assert(invariant(element, element.isImplementation));
     if (!this.applies(element, world)) return false;
 
     FunctionSignature parameters = element.functionSignature;
-    parameters.forEachRequiredParameter((element) {
+    parameters.forEachRequiredParameter((ParameterElement element) {
       list.add(compileArgument(arguments.head));
       arguments = arguments.tail;
     });
 
     if (!parameters.optionalParametersAreNamed) {
-      parameters.forEachOptionalParameter((element) {
+      parameters.forEachOptionalParameter((ParameterElement element) {
         if (!arguments.isEmpty) {
           list.add(compileArgument(arguments.head));
           arguments = arguments.tail;
         } else {
-          list.add(compileConstant(element));
+          list.add(compileDefaultValue(element));
         }
       });
     } else {
       // Visit named arguments and add them into a temporary list.
       List compiledNamedArguments = [];
       for (; !arguments.isEmpty; arguments = arguments.tail) {
         NamedArgument namedArgument = arguments.head;
         compiledNamedArguments.add(compileArgument(namedArgument.expression));
       }
       // Iterate over the optional parameters of the signature, and try to
       // find them in [compiledNamedArguments]. If found, we use the
       // value in the temporary list, otherwise the default value.
-      parameters.orderedOptionalParameters.forEach((element) {
+      parameters.orderedOptionalParameters.forEach((ParameterElement element) {
         int foundIndex = namedArguments.indexOf(element.name);
         if (foundIndex != -1) {
           list.add(compiledNamedArguments[foundIndex]);
         } else {
-          list.add(compileConstant(element));
+          list.add(compileDefaultValue(element));
         }
       });
     }
     return true;
   }
 
   /**
    * Fills [list] with the arguments in the order expected by
    * [callee], and where [caller] is a synthesized element
    *
@@ skipping 234 matching lines @@
 
   Selector extendIfReachesAll(Compiler compiler) {
     bool canReachAll = compiler.enabledInvokeOn
         && mask.needsNoSuchMethodHandling(this, compiler.world);
     return canReachAll
         ? new TypedSelector(
             compiler.typesTask.dynamicType, this, compiler.world)
         : this;
   }
 }