WIP: Compute constant expressions in resolution.

pkg/compiler/lib/src/resolution/constructors.dart

 // Copyright (c) 2015, 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.resolution.constructors;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
+    ErroneousConstantConstructor,
     GenerativeConstantConstructor,
     RedirectingGenerativeConstantConstructor;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     ConstructorElementX,
     ErroneousConstructorElementX,
     ErroneousElementX,
     ErroneousFieldElementX,
@@ skipping 103 matching lines @@
           init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     registry.useElement(init, target);
     registry.registerStaticUse(target);
     checkForDuplicateInitializers(target, init);
     // Resolve initializing value.
     ResolutionResult result = visitor.visitInStaticContext(
         init.arguments.head,
         inConstantInitializer: isConst);
     if (isConst) {
-      if (result.isConstant && field != null) {
-        // TODO(johnniwinther): Report error if `result.constant` is `null`.
-        fieldInitializers[field] = result.constant;
+      ConstantExpression constant;
+      if (result.isConstant) {
+        constant = result.constant;
       } else {
+        if (field != null) {
+          reporter.reportErrorMessage(
+              init, MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
+        }
+        constant = new ErroneousConstantExpression();
         isValidAsConstant = false;
       }
+      if (field != null) {
+        fieldInitializers[field] = constant;
+      }
     }
   }
 
   InterfaceType getSuperOrThisLookupTarget(Node diagnosticNode,
                                            {bool isSuperCall}) {
     if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
       if (identical(constructor.enclosingClass, visitor.compiler.objectClass)) {
         reporter.reportErrorMessage(
             diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
@@ skipping 236 matching lines @@
               isValidAsConstant = false;
             }
           });
           ResolutionResult result = resolveSuperOrThisForSend(call);
           if (isConst) {
             if (result.isConstant) {
               constructorInvocation = result.constant;
             } else {
               isValidAsConstant = false;
             }
-            if (isConst && isValidAsConstant) {
-              constructor.constantConstructor =
-                  new RedirectingGenerativeConstantConstructor(
-                      defaultValues,
-                      constructorInvocation);
+            if (isConst) {
+              if (isValidAsConstant) {
+                constructor.constantConstructor =
+                    new RedirectingGenerativeConstantConstructor(
+                        defaultValues,
+                        constructorInvocation);
+              } else {
+                constructor.constantConstructor =
+                    const ErroneousConstantConstructor();
+              }
             }
           }
           return result.element;
         } else {
           reporter.reportErrorMessage(
               call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
           return null;
         }
       } else {
         reporter.reportErrorMessage(
             link.head, MessageKind.INVALID_INITIALIZER);
+        isValidAsConstant = false;
       }
     }
     if (!resolvedSuper) {
       constructorInvocation = resolveImplicitSuperConstructorSend();
     }
-    if (isConst && isValidAsConstant) {
-      constructor.constantConstructor = new GenerativeConstantConstructor(
-          constructor.enclosingClass.thisType,
-          defaultValues,
-          fieldInitializers,
-          constructorInvocation);
+    if (isConst) {
+      ClassElement enclosingClass = constructor.enclosingClass;
+      enclosingClass.implementation.forEachInstanceField(
+          (ClassElement enclosingClass, FieldElementX field) {
+        if (field.isFinal) {
+          if (!fieldInitializers.containsKey(field)) {
+            visitor.compiler.resolver.resolveField(field);
+            Expression initializer = field.initializer;
+            if (initializer != null) {
+              fieldInitializers[field] = field.constant;
+            } else {
+              /*warning(functionNode, MessageKind.UNINITIALIZED_FINAL_FIELD, {
+                'fieldName': field.name,
+              });*/
+              fieldInitializers[field] = new NullConstantExpression();
+            }
+          }
+        } else {
+          isValidAsConstant = false;
+        }
+      });
+      if (isValidAsConstant) {
+        constructor.constantConstructor = new GenerativeConstantConstructor(
+            enclosingClass.thisType,
+            defaultValues,
+            fieldInitializers,
+            constructorInvocation);
+      } else {
+        constructor.constantConstructor =
+            const ErroneousConstantConstructor();
+      }
     }
     return null;  // If there was no redirection always return null.
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<ConstructorResult> {
   final ResolverVisitor resolver;
   final bool inConstContext;
 
   ConstructorResolver(Compiler compiler, this.resolver,
@@ skipping 317 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }