store constructor and arguments for constant values

pkg/analyzer/lib/src/dart/constant/value.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.
 
 /**
  * The implementation of the class [DartObject].
  */
 library analyzer.src.dart.constant.value;
 
 import 'dart:collection';
@@ skipping 118 matching lines @@
   String toString() => value == null ? "-unknown-" : (value ? "true" : "false");
 
   /**
    * Return the boolean state representing the given boolean [value].
    */
   static BoolState from(bool value) =>
       value ? BoolState.TRUE_STATE : BoolState.FALSE_STATE;
 }
 
 /**
+ * Information about a const constructor invocation.
+ */
+class ConstructorInvocation {
+  /**
+   * The constructor that was called.
+   */
+  final ConstructorElement constructor;
+
+  /**
+   * The positional arguments passed to the constructor.
+   */
+  final List<DartObjectImpl> positionalArguments;
+
+  /**
+   * The named arguments passed to the constructor.
+   */
+  final Map<String, DartObjectImpl> namedArguments;
+
+  ConstructorInvocation(
+      this.constructor, this.positionalArguments, this.namedArguments);
+}
+
+/**
  * A representation of an instance of a Dart class.
  */
 class DartObjectImpl implements DartObject {
   /**
    * An empty list of objects.
    */
   static const List<DartObjectImpl> EMPTY_LIST = const <DartObjectImpl>[];
 
   @override
   final ParameterizedType type;
@@ skipping 219 matching lines @@
 
   @override
   DartObject getField(String name) {
     InstanceState state = _state;
     if (state is GenericState) {
       return state.fields[name];
     }
     return null;
   }
 
+  /// Gets the constructor that was called to create this value, if this is a
+  /// const constructor invocation. Otherwise returns null.
+  ConstructorInvocation getInvocation() {
+    InstanceState state = _state;
+    if (state is GenericState) {
+      return state.invocation;
+    }
+    return null;
+  }
+
   /**
    * Return the result of invoking the '&gt;' operator on this object with the
    * [rightOperand]. The [typeProvider] is the type provider used to find known
    * types.
    *
    * Throws an [EvaluationException] if the operator is not appropriate for an
    * object of this kind.
    */
   DartObjectImpl greaterThan(
           TypeProvider typeProvider, DartObjectImpl rightOperand) =>
@@ skipping 927 matching lines @@
    */
   static GenericState UNKNOWN_VALUE =
       new GenericState(new HashMap<String, DartObjectImpl>());
 
   /**
    * The values of the fields of this instance.
    */
   final HashMap<String, DartObjectImpl> _fieldMap;
 
   /**
+   * Information about the constructor invoked to generate this instance.
+   */
+  final ConstructorInvocation invocation;
+
+  /**
    * Initialize a newly created state to represent a newly created object. The
    * [fieldMap] contains the values of the fields of the instance.
    */
-  GenericState(this._fieldMap);
+  GenericState(this._fieldMap, {this.invocation});
 
   @override
   HashMap<String, DartObjectImpl> get fields => _fieldMap;
 
   @override
   int get hashCode {
     int hashCode = 0;
     for (DartObjectImpl value in _fieldMap.values) {
       hashCode += value.hashCode;
     }
@@ skipping 1469 matching lines @@
       return BoolState.from(_type == rightType);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _type?.toString() ?? "-unknown-";
 }