Decouple the constant handler from the compiler so we can have more than one.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 66 matching lines @@
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. Otherwise returns `null`.
    */
   Constant compileVariable(VariableElement element, {bool isConst: false}) {
     return measure(() {
       if (initialVariableValues.containsKey(element)) {
         Constant result = initialVariableValues[element];
         return result;
       }
-      TreeElements definitions = compiler.analyzeElement(element);
-      Constant constant = compileVariableWithDefinitions(
-          element, definitions, isConst: isConst);
-      return constant;
+      return compiler.withCurrentElement(element, () {
+        TreeElements definitions = compiler.analyzeElement(element);
+        Constant constant = compileVariableWithDefinitions(
+            element, definitions, isConst: isConst);
+        return constant;
+      });
     });
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. If the variable needs to be initialized lazily returns `null`.
    * If the variable is `const` but cannot be compiled eagerly reports an
    * error.
    */
   Constant compileVariableWithDefinitions(VariableElement element,
@@ skipping 55 matching lines @@
       return value;
     });
   }
 
   Constant compileNodeWithDefinitions(Node node,
                                       TreeElements definitions,
                                       {bool isConst: false}) {
     return measure(() {
       assert(node != null);
       CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
-          constantSystem, definitions, compiler, isConst: isConst);
+          this, definitions, compiler, isConst: isConst);
       return evaluator.evaluate(node);
     });
   }
 
   /** Attempts to compile a constant expression. Returns null if not possible */
   Constant tryCompileNodeWithDefinitions(Node node, TreeElements definitions) {
     return measure(() {
       assert(node != null);
       try {
         TryCompileTimeConstantEvaluator evaluator =
-            new TryCompileTimeConstantEvaluator(constantSystem,
-                                                definitions,
-                                                compiler);
+            new TryCompileTimeConstantEvaluator(this, definitions, compiler);
         return evaluator.evaluate(node);
       } on CompileTimeConstantError catch (exn) {
         return null;
       }
     });
   }
 
   /**
    * Returns a [List] of static non final fields that need to be initialized.
    * The list must be evaluated in order since the fields might depend on each
@@ skipping 47 matching lines @@
     if (initialValue == null) {
       compiler.internalError("No initial value for given element",
                              element: element);
     }
     return initialValue;
   }
 }
 
 class CompileTimeConstantEvaluator extends Visitor {
   bool isEvaluatingConstant;
-  final ConstantSystem constantSystem;
+  final ConstantHandler handler;
   final TreeElements elements;
   final Compiler compiler;
   bool enabledRuntimeTypeSupport = false;
 
-  CompileTimeConstantEvaluator(this.constantSystem,
+  CompileTimeConstantEvaluator(this.handler,
                                this.elements,
                                this.compiler,
                                {bool isConst: false})
       : this.isEvaluatingConstant = isConst;
 
+  ConstantSystem get constantSystem => handler.constantSystem;
+
   Constant evaluate(Node node) {
     return node.accept(this);
   }
 
   Constant evaluateConstant(Node node) {
     bool oldIsEvaluatingConstant = isEvaluatingConstant;
     isEvaluatingConstant = true;
     Constant result = node.accept(this);
     isEvaluatingConstant = oldIsEvaluatingConstant;
     assert(result != null);
@@ skipping 22 matching lines @@
     }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty;
          link = link.tail) {
       arguments.add(evaluateConstant(link.head));
     }
     // TODO(floitsch): get type parameters.
     DartType type = new InterfaceType(compiler.listClass);
     Constant constant = new ListConstant(type, arguments);
-    compiler.constantHandler.registerCompileTimeConstant(constant);
+    handler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
     List<StringConstant> keys = <StringConstant>[];
     Map<StringConstant, Constant> map = new Map<StringConstant, Constant>();
     for (Link<Node> link = node.entries.nodes;
@@ skipping 15 matching lines @@
       if (key.value == MapConstant.PROTO_PROPERTY) {
         protoValue = map[key];
       } else {
         values.add(map[key]);
       }
     }
     bool hasProtoKey = (protoValue != null);
     // TODO(floitsch): this should be a List<String> type.
     DartType keysType = new InterfaceType(compiler.listClass);
     ListConstant keysList = new ListConstant(keysType, keys);
-    compiler.constantHandler.registerCompileTimeConstant(keysList);
+    handler.registerCompileTimeConstant(keysList);
     SourceString className = hasProtoKey
                              ? MapConstant.DART_PROTO_CLASS
                              : MapConstant.DART_CLASS;
     ClassElement classElement = compiler.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
     // TODO(floitsch): copy over the generic type.
     DartType type = new InterfaceType(classElement);
     registerInstantiatedClass(classElement);
     Constant constant = new MapConstant(type, keysList, values, protoValue);
-    compiler.constantHandler.registerCompileTimeConstant(constant);
+    handler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return constantSystem.createNull();
   }
 
   void registerInstantiatedClass(ClassElement element) {
     compiler.enqueuer.codegen.registerInstantiatedClass(element);
   }
@@ skipping 51 matching lines @@
       SourceString helperName = const SourceString('createRuntimeType');
       Element helper = compiler.findHelper(helperName);
       compiler.enqueuer.resolution.addToWorkList(helper);
       compiler.enqueuer.codegen.addToWorkList(helper);
       enabledRuntimeTypeSupport = true;
     }
 
     DartType elementType = element.computeType(compiler).asRaw();
     DartType constantType = compiler.typeClass.computeType(compiler);
     Constant constant = new TypeConstant(elementType, constantType);
-    compiler.constantHandler.registerCompileTimeConstant(constant);
+    handler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       if (Elements.isStaticOrTopLevelFunction(element)) {
         compiler.codegenWorld.staticFunctionsNeedingGetter.add(element);
         Constant constant = new FunctionConstant(element);
-        compiler.constantHandler.registerCompileTimeConstant(constant);
+        handler.registerCompileTimeConstant(constant);
         compiler.enqueuer.codegen.registerStaticUse(element);
         return constant;
       } else if (Elements.isStaticOrTopLevelField(element)) {
         Constant result;
         if (element.modifiers.isConst()) {
-          result = compiler.compileConstant(element);
+          result = handler.compileConstant(element);
         } else if (element.modifiers.isFinal() && !isEvaluatingConstant) {
-          result = compiler.compileVariable(element);
+          result = handler.compileVariable(element);
         }
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         return makeTypeConstant(element);
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isCall) {
       if (identical(element, compiler.identicalFunction)
           && send.argumentCount() == 2) {
         Constant left = evaluate(send.argumentsNode.nodes.head);
@@ skipping 129 matching lines @@
    * Invariant: [target] must be an implementation element.
    */
   List<Constant> evaluateArgumentsToConstructor(Node node,
                                                 Selector selector,
                                                 Link<Node> arguments,
                                                 FunctionElement target) {
     assert(invariant(node, target.isImplementation));
     List<Constant> compiledArguments = <Constant>[];
 
     Function compileArgument = evaluateConstant;
-    Function compileConstant = compiler.compileConstant;
+    Function compileConstant = handler.compileConstant;
     bool succeeded = selector.addArgumentsToList(arguments,
                                                  compiledArguments,
                                                  target,
                                                  compileArgument,
                                                  compileConstant,
                                                  compiler);
     if (!succeeded) {
       MessageKind kind = MessageKind.INVALID_ARGUMENTS;
       compiler.reportError(node,
           new CompileTimeConstantError(kind, [target.name.slowToString()]));
@@ skipping 17 matching lines @@
     }
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     constructor = constructor.implementation;
     assert(invariant(node, constructor.isImplementation));
 
     Selector selector = elements.getSelector(send);
     List<Constant> arguments = evaluateArgumentsToConstructor(
         node, selector, send.arguments, constructor);
     ConstructorEvaluator evaluator =
-        new ConstructorEvaluator(node, constructor, constantSystem, compiler);
+        new ConstructorEvaluator(node, constructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     compiler.enqueuer.codegen.registerInstantiatedClass(classElement);
     // TODO(floitsch): take generic types into account.
     DartType type = classElement.computeType(compiler);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
-    compiler.constantHandler.registerCompileTimeConstant(constant);
+    handler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 
   Constant signalNotCompileTimeConstant(Node node) {
     if (isEvaluatingConstant) {
       error(node);
     }
     // Else we don't need to do anything. The final handler is only
     // optimistically trying to compile constants. So it is normal that we
     // sometimes see non-compile time constants.
     // Simply return [:null:] which is used to propagate a failing
     // compile-time compilation.
     return null;
   }
 }
 
 class TryCompileTimeConstantEvaluator extends CompileTimeConstantEvaluator {
-  TryCompileTimeConstantEvaluator(ConstantSystem constantSystem,
+  TryCompileTimeConstantEvaluator(ConstantHandler handler,
                                   TreeElements elements,
                                   Compiler compiler)
-      : super(constantSystem, elements, compiler, isConst: true);
+      : super(handler, elements, compiler, isConst: true);
 
   error(Node node) {
     // Just fail without reporting it anywhere.
     throw new CompileTimeConstantError(
         MessageKind.NOT_A_COMPILE_TIME_CONSTANT, const []);
   }
 }
 
 class ConstructorEvaluator extends CompileTimeConstantEvaluator {
   final FunctionElement constructor;
   final Map<Element, Constant> definitions;
   final Map<Element, Constant> fieldValues;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] must be an implementation element.
    */
   ConstructorEvaluator(Node node,
                        FunctionElement constructor,
-                       ConstantSystem constantSystem,
+                       ConstantHandler handler,
                        Compiler compiler)
       : this.constructor = constructor,
         this.definitions = new Map<Element, Constant>(),
         this.fieldValues = new Map<Element, Constant>(),
-        super(constantSystem,
+        super(handler,
               compiler.resolver.resolveMethodElement(constructor.declaration),
               compiler,
               isConst: true) {
     assert(invariant(node, constructor.isImplementation));
   }
 
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
       Constant constant = definitions[element];
@@ skipping 46 matching lines @@
   }
 
   void evaluateSuperOrRedirectSend(Node currentNode,
                                    Selector selector,
                                    Link<Node> arguments,
                                    FunctionElement targetConstructor) {
     List<Constant> compiledArguments = evaluateArgumentsToConstructor(
         currentNode, selector, arguments, targetConstructor);
 
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
-        currentNode, targetConstructor, constantSystem, compiler);
+        currentNode, targetConstructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(compiledArguments);
     // Copy over the fieldValues from the super/redirect-constructor.
     // No need to go through [updateFieldValue] because the
     // assignments have already been checked in checked mode.
     evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
   }
 
   /**
    * Runs through the initializers of the given [constructor] and updates
    * the [fieldValues] map.
@@ skipping 68 matching lines @@
     });
   }
 
   List<Constant> buildJsNewArguments(ClassElement classElement) {
     List<Constant> jsNewArguments = <Constant>[];
     classElement.implementation.forEachInstanceField(
         (ClassElement enclosing, Element field) {
           Constant fieldValue = fieldValues[field];
           if (fieldValue == null) {
             // Use the default value.
-            fieldValue = compiler.compileConstant(field);
+            fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeBackendMembers: true,
         includeSuperMembers: true);
     return jsNewArguments;
   }
 }