Compute frontend/backend specific constants.

sdk/lib/_internal/compiler/implementation/compiler.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 dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 56 matching lines @@
 
 class DeferredTask {
   final Element element;
   final DeferredAction action;
 
   DeferredTask(this.element, this.action);
 }
 
 abstract class Backend {
   final Compiler compiler;
-  final ConstantSystem constantSystem;
 
-  Backend(this.compiler,
-          [ConstantSystem constantSystem = DART_CONSTANT_SYSTEM])
-      : this.constantSystem = constantSystem;
+  Backend(this.compiler);
+
+  /// The [ConstantSystem] used to interpret compile-time constants for this
+  /// backend.
+  ConstantSystem get constantSystem;
+
+  /// The constant environment for the backend interpretation of compile-time
+  /// constants.
+  BackendConstantEnvironment get constants;
+
+  /// The compiler task responsible for the compilation of constants for both
+  /// the frontend and the backend.
+  ConstantCompilerTask get constantCompilerTask;
 
   // Given a [FunctionElement], return a buffer with the code generated for it
   // or null if no code was generated.
   CodeBuffer codeOf(Element element) => null;
 
   void initializeHelperClasses() {}
 
   void enqueueHelpers(ResolutionEnqueuer world, TreeElements elements);
   void codegen(CodegenWorkItem work);
 
@@ skipping 458 matching lines @@
   ParserTask parser;
   PatchParserTask patchParser;
   LibraryLoader libraryLoader;
   TreeValidatorTask validator;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   IrBuilderTask irBuilder;
   ti.TypesTask typesTask;
   Backend backend;
-  ConstantHandler constantHandler;
+
+  /// The constant environment for the frontend interpretation of compile-time
+  /// constants.
+  ConstantEnvironment constants;
+
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   DumpInfoTask dumpInfoTask;
   String buildId;
 
   static const String MAIN = 'main';
   static const String CALL_OPERATOR_NAME = 'call';
   static const String NO_SUCH_METHOD = 'noSuchMethod';
   static const int NO_SUCH_METHOD_ARG_COUNT = 1;
@@ skipping 91 matching lines @@
 
     // No-op in production mode.
     validator = new TreeValidatorTask(this);
 
     tasks = [
       libraryLoader = new LibraryLoaderTask(this),
       scanner = new ScannerTask(this),
       dietParser = new DietParserTask(this),
       parser = new ParserTask(this),
       patchParser = new PatchParserTask(this),
-      resolver = new ResolverTask(this),
+      resolver = new ResolverTask(this, backend.constantCompilerTask),
       closureToClassMapper = new closureMapping.ClosureTask(this, closureNamer),
       checker = new TypeCheckerTask(this),
       irBuilder = new IrBuilderTask(this),
       typesTask = new ti.TypesTask(this),
-      constantHandler = new ConstantHandler(this, backend.constantSystem),
+      constants = backend.constantCompilerTask,
       deferredLoadTask = new DeferredLoadTask(this),
       mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
       enqueuer = new EnqueueTask(this),
       dumpInfoTask = new DumpInfoTask(this)];
 
     tasks.addAll(backend.tasks);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
@@ skipping 238 matching lines @@
           '$missingHelperClasses');
     }
 
     if (types == null) {
       types = new Types(this, dynamicClass);
     }
     backend.initializeHelperClasses();
 
     dynamicClass.ensureResolved(this);
 
-    proxyConstant = constantHandler.compileVariable(
-        coreLibrary.find('proxy'), isConst: true);
+    proxyConstant =
+        resolver.constantCompiler.compileConstant(coreLibrary.find('proxy'));
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
     Selector callConstructor = new Selector.callConstructor(
         "", listClass.getLibrary());
     return _unnamedListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
@@ skipping 843 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }