WIP: Compute constant expressions in resolution.

pkg/compiler/lib/src/resolution/resolution.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.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 37 matching lines @@
 import '../util/util.dart' show
     Link,
     LinkBuilder,
     Setlet;
 
 import 'class_hierarchy.dart';
 import 'class_members.dart' show MembersCreator;
 import 'constructors.dart';
 import 'members.dart';
 import 'registry.dart';
+import 'resolution_result.dart';
 import 'signatures.dart';
 import 'tree_elements.dart';
 import 'typedefs.dart';
 
 class ResolverTask extends CompilerTask {
   final ConstantCompiler constantCompiler;
 
   ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
@@ skipping 152 matching lines @@
         }
       }
 
       ResolverVisitor visitor = visitorFor(element);
       ResolutionRegistry registry = visitor.registry;
       registry.defineFunction(tree, element);
       visitor.setupFunction(tree, element);
       processAsyncMarker(compiler, element, registry);
 
       if (element.isGenerativeConstructor) {
+        ConstructorElementX constructor = element;
         // Even if there is no initializer list we still have to do the
         // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver =
-            new InitializerResolver(visitor, element, tree);
+            new InitializerResolver(visitor, constructor, tree);
         FunctionElement redirection = resolver.resolveInitializers();
+        constructor.constantConstructor;
+        /*if (constructor.isConst && !constructor.isFromEnvironmentConstructor) {
+          assert(invariant(constructor,
+              constructor.constantConstructorCache != null,
+              message: "Constant constructor has"))
+        }*/
         if (redirection != null) {
-          resolveRedirectingConstructor(resolver, tree, element, redirection);
+          resolveRedirectingConstructor(
+              resolver, tree, constructor, redirection);
         }
       } else if (tree.initializers != null) {
         reporter.reportErrorMessage(
             tree, MessageKind.FUNCTION_WITH_INITIALIZER);
       }
 
       if (!compiler.analyzeSignaturesOnly || tree.isRedirectingFactory) {
         // We need to analyze the redirecting factory bodies to ensure that
         // we can analyze compile-time constants.
         visitor.visit(tree.body);
@@ skipping 85 matching lines @@
         useEnclosingScope: useEnclosingScope);
   }
 
   WorldImpact resolveField(FieldElementX element) {
     VariableDefinitions tree = element.parseNode(parsing);
     if(element.modifiers.isStatic && element.isTopLevel) {
       reporter.reportErrorMessage(
           element.modifiers.getStatic(),
           MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
+    bool requireConstant = element.isConst;
+    if (!requireConstant && element.isInstanceMember) {
+      for (ConstructorElement constructor in
+               element.enclosingClass.constructors) {
+        if (constructor.isConst) {
+          requireConstant = true;
+          break;
+        }
+      }
+    }
     ResolverVisitor visitor = visitorFor(element);
     ResolutionRegistry registry = visitor.registry;
     // TODO(johnniwinther): Maybe remove this when placeholderCollector migrates
     // to the backend ast.
     registry.defineElement(tree.definitions.nodes.head, element);
     // TODO(johnniwinther): Share the resolved type between all variables
     // declared in the same declaration.
     if (tree.type != null) {
       element.variables.type = visitor.resolveTypeAnnotation(tree.type);
     } else {
       element.variables.type = const DynamicType();
     }
 
     Expression initializer = element.initializer;
     Modifiers modifiers = element.modifiers;
+    ResolutionResult result = const NoneResult();
     if (initializer != null) {
       // TODO(johnniwinther): Avoid analyzing initializers if
       // [Compiler.analyzeSignaturesOnly] is set.
-      visitor.visit(initializer);
+      //reportHere(reporter, element, 'resolveField:$element (${visitor.constantState}) (${initializer.runtimeType})');
+      if (requireConstant) {
+        result = visitor.visitInConstantContext(initializer);
+        visitor.checkConstantInvariant(initializer, result);
+      } else {
+        result = visitor.visit(initializer);
+      }
+      registry.setConstant(initializer, result.constant);
     } else if (modifiers.isConst) {
       reporter.reportErrorMessage(
           element, MessageKind.CONST_WITHOUT_INITIALIZER);
     } else if (modifiers.isFinal && !element.isInstanceMember) {
       reporter.reportErrorMessage(
           element, MessageKind.FINAL_WITHOUT_INITIALIZER);
     } else {
       registry.registerInstantiatedClass(compiler.nullClass);
     }
+    element.constant = result.constant;
 
     if (Elements.isStaticOrTopLevelField(element)) {
       visitor.addDeferredAction(element, () {
         if (element.modifiers.isConst) {
-          element.constant = constantCompiler.compileConstant(element);
+          // Ensure constant expression will be evaluated.
+          constantCompiler.compileConstant(element);
         } else {
           constantCompiler.compileVariable(element);
         }
       });
       if (initializer != null) {
         if (!element.modifiers.isConst) {
           // TODO(johnniwinther): Determine the const-ness eagerly to avoid
           // unnecessary registrations.
           registry.registerLazyField();
         }
@@ skipping 638 matching lines @@
       assert(invariant(node, context != null,
           message: "No context found for metadata annotation "
                    "on $annotatedElement."));
       ResolverVisitor visitor = visitorFor(context, useEnclosingScope: true);
       ResolutionRegistry registry = visitor.registry;
       node.accept(visitor);
       // TODO(johnniwinther): Avoid passing the [TreeElements] to
       // [compileMetadata].
       annotation.constant =
           constantCompiler.compileMetadata(annotation, node, registry.mapping);
-      constantCompiler.evaluate(annotation.constant);
+      constantCompiler.evaluate(node, annotation.constant);
       // TODO(johnniwinther): Register the relation between the annotation
       // and the annotated element instead. This will allow the backend to
       // retrieve the backend constant and only register metadata on the
       // elements for which it is needed. (Issue 17732).
       registry.registerMetadataConstant(annotation);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   List<MetadataAnnotation> resolveMetadata(Element element,
@@ skipping 24 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }