Move compile-time constant registrations to the backend.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1692 matching lines @@
       // property should not be mangled.
       if (backend.isTypedArray(
             node.receiver.instructionType.computeMask(compiler))) {
         // TODO(12929): Remove this custom code for typed arrays once V8
         // optimizes their length access.
         // Do a call to `fetchLength` instead of accessing `length`
         // directly. Because `fetchLength` is a constant we use its
         // constant value instead.
         Element element = compiler.findRequiredElement(
             compiler.typedDataLibrary, const SourceString('fetchLength'));
-        Constant constant = compiler.constantHandler.compileConstant(element);
+        Constant constant =
+            compiler.constantHandler.getConstantForVariable(element);
+        assert(invariant(element, constant != null,
+            message: 'No constant computed for $element'));
         var jsConstant = backend.emitter.constantReference(constant);
         push(new js.Call(jsConstant, [pop()]), node);
       } else {
         push(new js.PropertyAccess.field(pop(), 'length'), node);
       }
     } else {
       String name = _fieldPropertyName(element);
       push(new js.PropertyAccess.field(pop(), name), node);
       world.registerFieldGetter(element);
     }
@@ skipping 87 matching lines @@
     if (constant.isFunction()) {
       FunctionConstant function = constant;
       world.registerStaticUse(function.element);
     }
     push(backend.emitter.constantReference(constant));
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
     generateConstant(node.constant);
-    DartType type = node.constant.computeType(compiler);
-    if (node.constant is ConstructedConstant ||
-        node.constant is InterceptorConstant) {
-      ConstantHandler handler = compiler.constantHandler;
-      handler.registerCompileTimeConstant(node.constant, work.resolutionTree);
-    }
-    if (node.constant is! InterceptorConstant) {
-      world.registerInstantiatedClass(type.element, work.resolutionTree);
-    }
+
+    backend.registerCompileTimeConstant(node.constant, work.resolutionTree);
+    compiler.constantHandler.addCompileTimeConstantForEmission(node.constant);
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
     generateNot(node.inputs[0]);
     attachLocationToLast(node);
   }
 
   static String mapRelationalOperator(String op, bool inverse) {
     Map<String, String> inverseOperator = const <String, String>{
@@ skipping 1199 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive(compiler) && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }