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 34 matching lines @@
       // If we can't inline a function inside a loop, then we should not inline
       // it outside a loop either.
       canBeInlined[element] = false;
       canBeInlinedInsideLoop[element] = false;
     } else {
       canBeInlined[element] = false;
     }
   }
 }
 
-
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
@@ skipping 215 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;
 
+  JavaScriptConstantTask constantCompilerTask;
+
   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);
+    constantCompilerTask = new JavaScriptConstantTask(compiler);
+  }
+
+  ConstantSystem get constantSystem => constants.constantSystem;
+
+  JavaScriptConstantCompiler get constants {

[floitsch, 2014/04/07 12:21:42]

Add comment that these are now the JS constants.

[Johnni Winther, 2014/04/08 07:09:56]

Done.

+    return constantCompilerTask.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) {
-      Constant initialValue =
-          compiler.constantHandler.getConstantForVariable(element);
+      Constant initialValue = constants.getConstantForVariable(element);
       if (initialValue != null) {
         registerCompileTimeConstant(initialValue, work.resolutionTree);
-        compiler.constantHandler.addCompileTimeConstantForEmission(
-            initialValue);
+        constants.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.
         compiler.enqueuer.codegen.registerStaticUse(getCyclicThrowHelper());
@@ skipping 439 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 = constants.getConstantForMetadata(metadata);
+        constants.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);
 }
-