store constructor and arguments for constant values

pkg/analyzer/lib/src/dart/constant/evaluation.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 analyzer.src.dart.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 404 matching lines @@
       }
     }
     return value;
   }
 
   DartObjectImpl evaluateConstructorCall(
       AstNode node,
       List<Expression> arguments,
       ConstructorElement constructor,
       ConstantVisitor constantVisitor,
-      ErrorReporter errorReporter) {
+      ErrorReporter errorReporter,
+      {ConstructorElement originalConstructor,
+      List<DartObjectImpl> originalArguments,
+      Map<String, DartObjectImpl> originalNamedArguments}) {
     if (!getConstructorImpl(constructor).isCycleFree) {
       // It's not safe to evaluate this constructor, so bail out.
       // TODO(paulberry): ensure that a reasonable error message is produced
       // in this case, as well as other cases involving constant expression
       // circularities (e.g. "compile-time constant expression depends on
       // itself")
       return new DartObjectImpl.validWithUnknownValue(constructor.returnType);
     }
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues =
         new List<DartObjectImpl>(argumentCount);
+    List<DartObjectImpl> positionalArguments = <DartObjectImpl>[];
     List<Expression> argumentNodes = new List<Expression>(argumentCount);
     HashMap<String, DartObjectImpl> namedArgumentValues =
         new HashMap<String, DartObjectImpl>();
     HashMap<String, NamedExpression> namedArgumentNodes =
         new HashMap<String, NamedExpression>();
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       if (argument is NamedExpression) {
         String name = argument.name.label.name;
         namedArgumentValues[name] =
             constantVisitor._valueOf(argument.expression);
         namedArgumentNodes[name] = argument;
         argumentValues[i] = typeProvider.nullObject;
       } else {
-        argumentValues[i] = constantVisitor._valueOf(argument);
+        var argumentValue = constantVisitor._valueOf(argument);
+        argumentValues[i] = argumentValue;
+        positionalArguments.add(argumentValue);
         argumentNodes[i] = argument;
       }
     }
+    if (originalConstructor == null) {
+      originalConstructor = constructor;
+      originalArguments = positionalArguments;
+      originalNamedArguments = namedArgumentValues;
+    }
     constructor = followConstantRedirectionChain(constructor);
     InterfaceType definingClass = constructor.returnType as InterfaceType;
     if (constructor.isFactory) {
       // We couldn't find a non-factory constructor.
       // See if it's because we reached an external const factory constructor
       // that we can emulate.
       if (constructor.name == "fromEnvironment") {
         if (!checkFromEnvironmentArguments(
             arguments, argumentValues, namedArgumentValues, definingClass)) {
           errorReporter.reportErrorForNode(
@@ skipping 237 matching lines @@
       } else if (initializer is RedirectingConstructorInvocation) {
         // This is a redirecting constructor, so just evaluate the constructor
         // it redirects to.
         ConstructorElement constructor = initializer.staticElement;
         if (constructor != null && constructor.isConst) {
           return evaluateConstructorCall(
               node,
               initializer.argumentList.arguments,
               constructor,
               initializerVisitor,
-              errorReporter);
+              errorReporter,
+              originalConstructor: originalConstructor,
+              originalArguments: originalArguments,
+              originalNamedArguments: originalNamedArguments);
         }
       }
     }
     // Evaluate explicit or implicit call to super().
     InterfaceType superclass = definingClass.superclass;
     if (superclass != null && !superclass.isObject) {
       ConstructorElement superConstructor =
           superclass.lookUpConstructor(superName, constructor.library);
       if (superConstructor != null) {
         if (superArguments == null) {
           superArguments = astFactory.nodeList/*<Expression>*/(null);
         }
 
         evaluateSuperConstructorCall(node, fieldMap, superConstructor,
             superArguments, initializerVisitor, errorReporter);
       }
     }
-    return new DartObjectImpl(definingClass, new GenericState(fieldMap));
+    return new DartObjectImpl(
+        definingClass,
+        new GenericState(fieldMap,
+            constructor: originalConstructor,
+            positionalArguments: originalArguments,
+            namedArguments: originalNamedArguments));
   }
 
   void evaluateSuperConstructorCall(
       AstNode node,
       HashMap<String, DartObjectImpl> fieldMap,
       ConstructorElement superConstructor,
       List<Expression> superArguments,
       ConstantVisitor initializerVisitor,
       ErrorReporter errorReporter) {
     if (superConstructor != null && superConstructor.isConst) {
@@ skipping 1345 matching lines @@
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }