Fix ParameterMirror.hasDefaultValue/defaultValue in source mirrors.

sdk/lib/_internal/compiler/implementation/compile_time_constants.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 dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
  */
 class ConstantHandler extends CompilerTask {
   final ConstantSystem constantSystem;
   final bool isMetadata;
 
   /**
    * Contains the initial value of fields. Must contain all static and global
    * initializations of const fields. May contain eagerly compiled values for
    * statics and instance fields.
+   *
+   * Invariant: The keys in this map are declarations.
    */
   final Map<VariableElement, Constant> initialVariableValues;
 
   /** Set of all registered compiled constants. */
   final Set<Constant> compiledConstants;
 
   /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables;
 
   /** Caches the statics where the initial value cannot be eagerly compiled. */
   final Set<VariableElement> lazyStatics;
 
   ConstantHandler(Compiler compiler, this.constantSystem,
                   { bool this.isMetadata: false })
       : initialVariableValues = new Map<VariableElement, dynamic>(),
         compiledConstants = new Set<Constant>(),
         pendingVariables = new Set<VariableElement>(),
         lazyStatics = new Set<VariableElement>(),
         super(compiler);
 
   String get name => 'ConstantHandler';
 
   void addCompileTimeConstantForEmission(Constant constant) {
     compiledConstants.add(constant);
   }
 
   Constant getConstantForVariable(VariableElement element) {
-    return initialVariableValues[element];
+    return initialVariableValues[element.declaration];
   }
 
   /**
    * Returns a compile-time constant, or reports an error if the element is not
    * a compile-time constant.
    */
   Constant compileConstant(VariableElement element) {
     return compileVariable(element, isConst: true);
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. Otherwise returns `null`.
    */
   Constant compileVariable(VariableElement element, {bool isConst: false}) {
     return measure(() {
-      if (initialVariableValues.containsKey(element)) {
-        Constant result = initialVariableValues[element];
+      if (initialVariableValues.containsKey(element.declaration)) {
+        Constant result = initialVariableValues[element.declaration];
         return result;
       }
       Element currentElement = element;
       if (element.isParameter()
           || element.isFieldParameter()
           || element.isVariable()) {
         currentElement = element.enclosingElement;
       }
       return compiler.withCurrentElement(currentElement, () {
         TreeElements definitions =
@@ skipping 62 matching lines @@
               } else {
                 // If the field cannot be lazily initialized, we will throw
                 // the exception at runtime.
                 value = null;
               }
             }
           }
         }
       }
       if (value != null) {
-        initialVariableValues[element] = value;
+        initialVariableValues[element.declaration] = value;
       } else {
         assert(!isConst);
         lazyStatics.add(element);
       }
       pendingVariables.remove(element);
       return value;
     });
   }
 
   Constant compileNodeWithDefinitions(Node node,
@@ skipping 57 matching lines @@
 
     List<Constant> sorted = compiledConstants.toList();
     if (preSortCompare != null) {
       sorted.sort(preSortCompare);
     }
     sorted.forEach(addConstant);
     return result;
   }
 
   Constant getInitialValueFor(VariableElement element) {
-    Constant initialValue = initialVariableValues[element];
+    Constant initialValue = initialVariableValues[element.declaration];
     if (initialValue == null) {
       compiler.internalError("No initial value for given element",
                              element: element);
     }
     return initialValue;
   }
 }
 
 class CompileTimeConstantEvaluator extends Visitor {
   bool isEvaluatingConstant;
@@ skipping 714 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }