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);

[floitsch, 2014/04/02 16:50:02]

Add comments what and when they are used.
Are they always doing backend-constant handling?
Do they also do Dart-handling?
May they ever expose non-Dart handling?

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

Done.

+
+  ConstantSystem get constantSystem;
+
+  BackendConstantHandler get constantHandler;
+
+  ConstantCompiler get constantCompiler;
 
   // 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 570 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.constantCompiler),
       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),
+      constantHandler = backend.constantCompiler,

[floitsch, 2014/04/02 16:50:02]

It feels wrong (when reading) to assign a compiler to a handler. Especially when
the backend also has a constantHandler.

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

Done.

       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'));

[floitsch, 2014/04/02 16:50:02]

Why go through the resolver?

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

We need the frontend interpretation. Putting the constant compiler on the
resolver instead of on the Compiler itself is deliberate, to show that
compilation of compile-time constants is part of the resolution phase.

   }
 
   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;
 }