Add CoreTypes interface.

pkg/compiler/lib/src/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 const bool USE_CPS_IR = const bool.fromEnvironment("USE_CPS_IR");
 
@@ skipping 746 matching lines @@
 
   void registerCompileTimeConstant(ConstantValue constant, Registry registry) {
     registerCompileTimeConstantInternal(constant, registry);
     for (ConstantValue dependency in constant.getDependencies()) {
       registerCompileTimeConstant(dependency, registry);
     }
   }
 
   void registerCompileTimeConstantInternal(ConstantValue constant,
                                            Registry registry) {
-    DartType type = constant.computeType(compiler);
+    DartType type = constant.getType(compiler.coreTypes);
     registerInstantiatedConstantType(type, registry);
 
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
       registry.registerGetOfStaticFunction(function.element);
     } else if (constant.isInterceptor) {
       // An interceptor constant references the class's prototype chain.
       InterceptorConstantValue interceptor = constant;
       registerInstantiatedConstantType(interceptor.dispatchedType, registry);
     } else if (constant.isType) {
@@ skipping 1166 matching lines @@
   bool matchesMirrorsMetaTarget(Element element) {
     if (metaTargetsUsed.isEmpty) return false;
     for (Link link = element.metadata; !link.isEmpty; link = link.tail) {
       MetadataAnnotation metadata = link.head;
       // TODO(kasperl): It would be nice if we didn't have to resolve
       // all metadata but only stuff that potentially would match one
       // of the used meta targets.
       metadata.ensureResolved(compiler);
       ConstantValue value = metadata.constant.value;
       if (value == null) continue;
-      DartType type = value.computeType(compiler);
+      DartType type = value.getType(compiler.coreTypes);
       if (metaTargetsUsed.contains(type.element)) return true;
     }
     return false;
   }
 
   /**
    * Visits all classes and computes whether its members are needed for
    * reflection.
    *
    * We have to precompute this set as we cannot easily answer the need for
@@ skipping 541 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }