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

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 184 matching lines @@
         // TODO(karlklose,ngeoffray): add a check to make sure that element is
         // of type FunctionElement.
         FunctionElement function = element;
         OptionalParameterTypes defaultValueTypes = null;
         FunctionSignature signature = function.computeSignature(compiler);
         if (signature.optionalParameterCount > 0) {
           defaultValueTypes =
               new OptionalParameterTypes(signature.optionalParameterCount);
           int index = 0;
           signature.forEachOptionalParameter((Element parameter) {
-            Constant defaultValue = compiler.compileVariable(parameter);
+            Constant defaultValue = builder.compileVariable(parameter);
             HType type = HGraph.mapConstantTypeToSsaType(defaultValue);
             defaultValueTypes.update(index, parameter.name, type);
             index++;
           });
         } else {
           // TODO(ahe): I have disabled type optimizations for
           // optional arguments as the types are stored in the wrong
           // order.
           HTypeList parameterTypes =
               backend.optimisticParameterTypes(element.declaration,
@@ skipping 765 matching lines @@
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
     assert(!methodInterceptionEnabled);
     methodInterceptionEnabled = true;
   }
 
   /**
+   * Compiles compile-time constants. Never returns [:null:]. If the
+   * initial value is not a compile-time constants, it reports an
+   * internal error.
+   */
+  Constant compileConstant(VariableElement element) {
+    return compiler.constantHandler.compileConstant(element);
+  }
+
+  Constant compileVariable(VariableElement element) {
+    return compiler.constantHandler.compileVariable(element);
+  }
+
+  bool isLazilyInitialized(VariableElement element) {
+    Constant initialValue = compileVariable(element);
+    return initialValue == null;
+  }
+
+  /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     FunctionExpression function = functionElement.parseNode(compiler);
     assert(function != null);
     assert(!function.modifiers.isExternal());
     assert(elements[function] != null);
@@ skipping 516 matching lines @@
       //   if (?a) print('parameter passed $a');
       // }
       //
       // foo([a = 42]) {
       //   var t1 = identical(a, sentinel);
       //   if (t1) a = 42;
       //   if (!t1) print('parameter passed ' + a);
       // }
 
       // Fetch the original default value of [element];
-      ConstantHandler handler = compiler.constantHandler;
-      Constant constant = handler.compileVariable(element);
+      Constant constant = compileVariable(element);
       HConstant defaultValue = constant == null
           ? graph.addConstantNull(constantSystem)
           : graph.addConstant(constant);
 
       // Emit the equality check with the sentinel.
       HConstant sentinel = graph.addConstant(SentinelConstant.SENTINEL);
       Element equalsHelper = interceptors.getTripleEqualsInterceptor();
       HInstruction target = new HStatic(equalsHelper);
       add(target);
       HInstruction operand = parameters[element];
@@ skipping 912 matching lines @@
           new HInvokeDynamicGetter(selector, null, receiver, !hasGetter), send);
     }
   }
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
-        value = compiler.compileVariable(element);
+        value = compileVariable(element);
       }
       if (value != null) {
         stack.add(graph.addConstant(value));
-      } else if (element.isField() && compiler.isLazilyInitialized(element)) {
+      } else if (element.isField() && isLazilyInitialized(element)) {
         push(new HLazyStatic(element));
       } else {
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         push(new HStatic(element.declaration));
         if (element.isGetter()) {
           push(new HInvokeStatic(<HInstruction>[pop()]));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
@@ skipping 258 matching lines @@
                                     Link<Node> arguments,
                                     FunctionElement element,
                                     List<HInstruction> list) {
     assert(invariant(element, element.isImplementation));
 
     HInstruction compileArgument(Node argument) {
       visit(argument);
       return pop();
     }
 
-    HInstruction compileConstant(Element parameter) {
+    HInstruction handleConstant(Element parameter) {
       Constant constant;
       TreeElements calleeElements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (calleeElements.isParameterChecked(parameter)) {
         constant = SentinelConstant.SENTINEL;
       } else {
-        constant = compiler.compileConstant(parameter);
+        constant = compileConstant(parameter);
       }
       return graph.addConstant(constant);
     }
 
     return selector.addArgumentsToList(arguments,
                                        list,
                                        element,
                                        compileArgument,
-                                       compileConstant,
+                                       handleConstant,
                                        compiler);
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
@@ skipping 2133 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }