WIP: Compute constant expressions in resolution.

pkg/compiler/lib/src/constants/values.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 dart2js.constants.values;
 
 import '../common.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
-import '../elements/elements.dart'
-    show ClassElement,
-         Element,
-         FieldElement,
-         FunctionElement,
-         PrefixElement;
+import '../diagnostics/invariant.dart' show
+    DEBUG_MODE;
+import '../elements/elements.dart' show
+    ClassElement,
+    Element,
+    FieldElement,
+    FunctionElement,
+    PrefixElement;
 import '../tree/tree.dart' hide unparse;
-import '../util/util.dart' show Hashing;
+import '../util/util.dart' show
+    Hashing;
 
 abstract class ConstantValueVisitor<R, A> {
   const ConstantValueVisitor();
 
   R visitFunction(FunctionConstantValue constant, A arg);
   R visitNull(NullConstantValue constant, A arg);
   R visitInt(IntConstantValue constant, A arg);
   R visitDouble(DoubleConstantValue constant, A arg);
   R visitBool(BoolConstantValue constant, A arg);
   R visitString(StringConstantValue constant, A arg);
   R visitList(ListConstantValue constant, A arg);
   R visitMap(MapConstantValue constant, A arg);
   R visitConstructed(ConstructedConstantValue constant, A arg);
   R visitType(TypeConstantValue constant, A arg);
   R visitInterceptor(InterceptorConstantValue constant, A arg);
   R visitSynthetic(SyntheticConstantValue constant, A arg);
   R visitDeferred(DeferredConstantValue constant, A arg);
+  R visitNonConstant(NonConstantValue constant, A arg);
 }
 
 abstract class ConstantValue {
   const ConstantValue();
 
   /// `true` if this is a valid constant value.
   bool get isConstant => true;
 
   bool get isNull => false;
   bool get isBool => false;
@@ skipping 581 matching lines @@
 
   String unparse() => 'synthetic($kind, $payload)';
 
   String toStructuredString() => 'SyntheticConstant($kind, $payload)';
 }
 
 class ConstructedConstantValue extends ObjectConstantValue {
   final Map<FieldElement, ConstantValue> fields;
   final int hashCode;
 
-  ConstructedConstantValue(InterfaceType type,
-                           Map<FieldElement, ConstantValue> fields)
-    : this.fields = fields,
-      hashCode = Hashing.mapHash(fields, Hashing.objectHash(type)),
-      super(type) {
+  factory ConstructedConstantValue(
+      InterfaceType type,
+      Map<FieldElement, ConstantValue> fields) {
+    fields = normalizeFields(type, fields);
+    int hashCode = Hashing.mapHash(fields, Hashing.objectHash(type));
+    return new ConstructedConstantValue._(type, fields, hashCode);
+  }
+
+  ConstructedConstantValue._(InterfaceType type, this.fields, this.hashCode)
+    : super(type) {
     assert(type != null);
-    assert(!fields.containsValue(null));
+    assert(invariant(NO_LOCATION_SPANNABLE, !fields.containsValue(null),
+        message: () {
+          DEBUG_MODE = true;
+          return "Null field value for constructed constant of type '$type' "
+                 "with fields ${fields}.";
+        }));
+  }
+
+  static Map<FieldElement, ConstantValue> normalizeFields(
+      InterfaceType type, Map<FieldElement, ConstantValue> fields) {
+    Map<FieldElement, ConstantValue> normalizedFields =
+        <FieldElement, ConstantValue>{};
+    type.element.implementation.forEachInstanceField(
+        (ClassElement enclosingClass, FieldElement field) {
+      assert(invariant(NO_LOCATION_SPANNABLE, fields.containsKey(field),
+          message: () {
+            DEBUG_MODE = true;
+            return "No field value provided for $field in constructed constant "
+                   "of type '$type' with fields ${fields}.";
+          }));
+      normalizedFields[field] = fields[field];
+    }, includeSuperAndInjectedMembers: true);
+    return normalizedFields;
   }
 
   bool get isConstructedObject => true;
 
   bool operator ==(var otherVar) {
     if (otherVar is !ConstructedConstantValue) return false;
     ConstructedConstantValue other = otherVar;
     if (hashCode != other.hashCode) return false;
     if (type != other.type) return false;
     if (fields.length != other.fields.length) return false;
@@ skipping 74 matching lines @@
 }
 
 /// A constant value resulting from a non constant or erroneous constant
 /// expression.
 // TODO(johnniwinther): Expand this to contain the error kind.
 class NonConstantValue extends ConstantValue {
   bool get isConstant => false;
 
   @override
   accept(ConstantValueVisitor visitor, arg) {
-    // TODO(johnniwinther): Should this be part of the visiting?
+    return visitor.visitNonConstant(this, arg);
   }
 
   @override
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   @override
   DartType getType(CoreTypes types) => const DynamicType();
 
   @override
   String toStructuredString() => 'NonConstant';
 
   @override
   String unparse() => '>>non-constant<<';
-}
+}