WIP: Compute constant expressions in resolution.

pkg/compiler/lib/src/compile_time_constants.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.compile_time_constant_evaluator;
 
 import 'common.dart';
 import 'common/resolution.dart' show
     Resolution;
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
+import 'constants/constructors.dart';
 import 'constants/evaluation.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
+import 'core_types.dart';
 import 'dart_types.dart';
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show
     FunctionElementX;
+import 'enqueue.dart' show
+    WorldImpact;
 import 'resolution/tree_elements.dart' show
     TreeElements;
 import 'resolution/operators.dart';
 import 'tree/tree.dart';
 import 'util/util.dart' show
     Link;
 import 'universe/call_structure.dart' show
     CallStructure;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
@@ skipping 51 matching lines @@
   /// Depending on implementation, the constant compiler might also compute
   /// the compile-time constant for the backend interpretation of constants.
   ///
   /// The returned constant is always of the frontend interpretation.
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                                      Node node,
                                      TreeElements elements);
 
   /// Evaluates [constant] and caches the result.
   // TODO(johnniwinther): Remove when all constants are evaluated.
-  void evaluate(ConstantExpression constant);
+  void evaluate(Spannable spannable, ConstantExpression constant);
 }
 
 /// A [BackendConstantEnvironment] provides access to constants needed for
 /// backend implementation.
 abstract class BackendConstantEnvironment extends ConstantEnvironment {
   /// Returns the compile-time constant value associated with [node].
   ///
   /// Depending on implementation, the constant might be stored in [elements].
   ConstantValue getConstantValueForNode(Node node, TreeElements elements);
 
@@ skipping 63 matching lines @@
   @override
   ConstantExpression getConstantForVariable(VariableElement element) {
     return initialVariableValues[element.declaration];
   }
 
   ConstantExpression compileConstant(VariableElement element) {
     return internalCompileVariable(element, true, true);
   }
 
   @override
-  void evaluate(ConstantExpression constant) {
+  void evaluate(Spannable spannable, ConstantExpression constant) {
     constantValueMap.putIfAbsent(constant, () {
       return constant.evaluate(
-          new _CompilerEnvironment(compiler),
+          new CompilerEnvironment(compiler, spannable),
           constantSystem);
     });
   }
 
   ConstantExpression compileVariable(VariableElement element) {
     return internalCompileVariable(element, false, true);
   }
 
   /// Compile [element] into a constant expression. If [isConst] is true,
   /// then [element] is a constant variable. If [checkType] is true, then
@@ skipping 91 matching lines @@
     return expression;
   }
 
   void cacheConstantValue(ConstantExpression expression, ConstantValue value) {
     constantValueMap[expression] = value;
   }
 
   ConstantExpression compileNodeWithDefinitions(
       Node node, TreeElements definitions, {bool isConst: true}) {
     assert(node != null);
+    ConstantExpression constantExpression = definitions.getConstant(node);
+    if (constantExpression != null) {
+      constantValueMap.putIfAbsent(constantExpression, () {
+        return constantExpression.evaluate(
+            new CompilerEnvironment(compiler, node), constantSystem);
+      });
+      return constantExpression;
+    }
     CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
         this, definitions, compiler, isConst: isConst);
     AstConstant constant = evaluator.evaluate(node);
     if (constant != null) {
       cacheConstantValue(constant.expression, constant.value);
       return constant.expression;
     }
     return null;
+    /*
+    if (constantExpression == null) {
+      compiler.internalError(node, "No constant computed for $node.");
+    }
+    constantValueMap.putIfAbsent(
+        constantExpression, () {
+      return constantExpression.evaluate(
+          new CompilerEnvironment(compiler, node), constantSystem);
+    });
+    return constantExpression;*/
   }
 
   ConstantValue getConstantValue(ConstantExpression expression) {
     return constantValueMap[expression];
   }
 
   ConstantExpression compileNode(Node node, TreeElements elements,
       {bool enforceConst: true}) {
     return compileNodeWithDefinitions(node, elements, isConst: enforceConst);
   }
 
   ConstantExpression compileMetadata(
       MetadataAnnotation metadata, Node node, TreeElements elements) {
     return compileNodeWithDefinitions(node, elements);
   }
 
   void forgetElement(Element element) {
     initialVariableValues.remove(element);
     if (element is ScopeContainerElement) {
       element.forEachLocalMember(initialVariableValues.remove);
     }
     if (element is FunctionElement && element.hasFunctionSignature) {
       element.functionSignature.forEachParameter(this.forgetElement);
     }
   }
 }
 
+class CompilerEnvironment implements Environment {
+  final Compiler compiler;
+  final Spannable spannable;
+  final Set<VariableElement> evaluatingVariables = new Set<VariableElement>();
+  final Set<ConstructorElement> evaluatingConstructors =
+      new Set<ConstructorElement>();
+
+  CompilerEnvironment(this.compiler, this.spannable);
+
+  @override
+  CoreTypes get coreTypes => compiler.coreTypes;
+
+  @override
+  String readFromEnvironment(String name) => compiler.fromEnvironment(name);
+
+  @override
+  void reportWarning(ConstantExpression expression,
+                     MessageKind kind,
+                     Map arguments) {
+    compiler.reporter.reportWarningMessage(spannable, kind, arguments);
+  }
+
+  @override
+  void reportError(ConstantExpression expression,
+                   MessageKind kind,
+                   Map arguments) {
+    compiler.reporter.reportErrorMessage(spannable, kind, arguments);
+  }
+
+  @override
+  ConstantValue evaluateConstructor(
+      ConstructorElement constructor,
+      ConstantValue evaluate()) {
+    if (evaluatingConstructors.contains(constructor)) {
+      return new NonConstantValue();
+    }
+    ConstructorElement parentConstructor = constructor;
+    while (parentConstructor != null) {
+      _analyzeElementEagerly(compiler, parentConstructor);
+      ConstantConstructor constantConstructor =
+          parentConstructor.constantConstructor;
+      assert(invariant(parentConstructor, constantConstructor != null,
+          message: "No constant constructor on ${parentConstructor}."));
+      parentConstructor = constantConstructor.parentConstructor;
+    }
+    evaluatingConstructors.add(constructor);
+    ConstantValue value = evaluate();
+    evaluatingConstructors.remove(constructor);
+    return value;
+  }
+
+  @override
+  ConstantValue evaluateVariable(
+      VariableElement variable,
+      ConstantValue evaluate()) {
+    if (evaluatingVariables.contains(variable)) {
+      return new NonConstantValue();
+    }
+    if (!variable.isLocal) {
+      _analyzeElementEagerly(compiler, variable);
+    }
+    evaluatingVariables.add(variable);
+    ConstantValue value = evaluate();
+    evaluatingVariables.remove(variable);
+    return value;
+  }
+}
+
 /// [ConstantCompiler] that uses the Dart semantics for the compile-time
 /// constant evaluation.
 class DartConstantCompiler extends ConstantCompilerBase {
   DartConstantCompiler(Compiler compiler)
       : super(compiler, const DartConstantSystem());
 
   ConstantExpression getConstantForNode(Node node, TreeElements definitions) {
     return definitions.getConstant(node);
   }
 
@@ skipping 529 matching lines @@
       return makeConstructedConstant(compiler, handler, context, node, type,
           constructor, constructedType, implementation, callStructure,
           concreteArguments, normalizedArguments);
     }
   }
 
   AstConstant createFromEnvironmentConstant(Node node, InterfaceType type,
       ConstructorElement constructor, CallStructure callStructure,
       List<AstConstant> normalizedArguments,
       List<AstConstant> concreteArguments) {
-    var firstArgument = normalizedArguments[0].value;
+
+    ConstantValue firstArgument = normalizedArguments[0].value;
     ConstantValue defaultValue = normalizedArguments[1].value;
 
     if (firstArgument.isNull) {
       reporter.reportErrorMessage(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
       return null;
     }
 
     if (!firstArgument.isString) {
-      DartType type = defaultValue.getType(compiler.coreTypes);
+      DartType type = firstArgument.getType(compiler.coreTypes);
       reporter.reportErrorMessage(
           normalizedArguments[0].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type,
            'toType': compiler.stringClass.rawType});
       return null;
     }
 
     if (constructor == compiler.intEnvironment &&
         !(defaultValue.isNull || defaultValue.isInt)) {
@@ skipping 21 matching lines @@
         !(defaultValue.isNull || defaultValue.isString)) {
       DartType type = defaultValue.getType(compiler.coreTypes);
       reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type,
            'toType': compiler.stringClass.rawType});
       return null;
     }
 
-    String name = firstArgument.primitiveValue.slowToString();
+    PrimitiveConstantValue nameArgument = firstArgument;
+    String name = nameArgument.primitiveValue.slowToString();
     String value = compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
       if (concreteArguments.length > 1) {
         defaultValue = concreteArguments[1].expression;
       }
       if (constructor == compiler.intEnvironment) {
@@ skipping 316 matching lines @@
   ErroneousAstConstant(Element element, Node node) : super(element, node,
           // TODO(johnniwinther): Return a [NonConstantValue] instead.
           new ErroneousConstantExpression(), new NullConstantValue());
 }
 
 // TODO(johnniwinther): Clean this up.
 TreeElements _analyzeElementEagerly(Compiler compiler, AstElement element) {
   compiler.resolution.analyzeElement(element.declaration);
   return element.resolvedAst.elements;
 }
-
-class _CompilerEnvironment implements Environment {
-  final Compiler compiler;
-
-  _CompilerEnvironment(this.compiler);
-
-  @override
-  String readFromEnvironment(String name) {
-    return compiler.fromEnvironment(name);
-  }
-}