Compute frontend/backend specific constants.

sdk/lib/_internal/compiler/implementation/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;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 270 matching lines @@
 
   TypeVariableHandler typeVariableHandler;
 
   /// Number of methods compiled before considering reflection.
   int preMirrorsMethodCount = 0;
 
   /// Resolution and codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsAnalysis customElementsAnalysis;
 
+  JavaScriptConstantHandler constantCompiler;
+
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
-        super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
+        super(compiler) {
     emitter = new CodeEmitterTask(compiler, namer, generateSourceMap);
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
     typeVariableHandler = new TypeVariableHandler(this);
     customElementsAnalysis = new CustomElementsAnalysis(this);
+    constantCompiler = new JavaScriptConstantHandler(compiler);
+  }
+
+  ConstantSystem get constantSystem => constantHandler.constantSystem;
+
+  JavaScriptBackendConstantHandler get constantHandler {
+    return constantCompiler.jsConstantCompiler;
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
         new MinifyNamer(compiler) :
         new Namer(compiler);
   }
 
   bool usedByBackend(Element element) {
     if (element.isParameter()
@@ skipping 821 matching lines @@
 
   void codegen(CodegenWorkItem work) {
     Element element = work.element;
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) return;
     if (element.isConstructor() && element.getEnclosingClass() == jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
       return;
     }
     if (kind.category == ElementCategory.VARIABLE) {
+      JavaScriptBackend backend = compiler.backend;

[karlklose, 2014/04/02 13:04:44]

Isn't this the JavaScriptBackend?

[Johnni Winther, 2014/04/07 11:42:27]

Yes! Removed.

       Constant initialValue =
-          compiler.constantHandler.getConstantForVariable(element);
+          backend.constantHandler.getConstantForVariable(element);
       if (initialValue != null) {
         registerCompileTimeConstant(initialValue, work.resolutionTree);
-        compiler.constantHandler.addCompileTimeConstantForEmission(
+        backend.constantHandler.addCompileTimeConstantForEmission(
             initialValue);
         // We don't need to generate code for static or top-level
         // variables. For instance variables, we may need to generate
         // the checked setter.
         if (Elements.isStaticOrTopLevel(element)) return;
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
@@ skipping 440 matching lines @@
     return symbolsUsed.contains(name);
   }
 
   bool get rememberLazies => isTreeShakingDisabled;
 
   bool retainMetadataOf(Element element) {
     if (mustRetainMetadata) hasRetainedMetadata = true;
     if (mustRetainMetadata && isNeededForReflection(element)) {
       for (MetadataAnnotation metadata in element.metadata) {
         metadata.ensureResolved(compiler);
-        compiler.constantHandler.addCompileTimeConstantForEmission(
-            metadata.value);
+        Constant constant = constantHandler.getConstantForMetadata(metadata);
+        constantHandler.addCompileTimeConstantForEmission(constant);
       }
       return true;
     }
     return false;
   }
 
   Future onLibraryLoaded(LibraryElement library, Uri uri) {
     if (uri == Uri.parse('dart:_js_mirrors')) {
       disableTreeShakingMarker =
           library.find('disableTreeShaking');
@@ skipping 257 matching lines @@
   }
 }
 
 /// Records that [constant] is used by [user.element].
 class Dependency {
   final Constant constant;
   final TreeElements user;
 
   const Dependency(this.constant, this.user);
 }
-