Move compile-time constant registrations to the backend.

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 105 matching lines @@
   // TODO(ahe,karlklose): rename this?
   void dumpInferredTypes() {}
 
   ItemCompilationContext createItemCompilationContext() {
     return new ItemCompilationContext();
   }
 
   bool classNeedsRti(ClassElement cls);
   bool methodNeedsRti(FunctionElement function);
 
+
+  /// Called by the backend when [constant] has been used.

[ngeoffray, 2013/10/01 08:33:35]

Please update comment: how can that be called by the backend, being it a method
on the backend?

[Johnni Winther, 2013/10/01 11:21:48]

Done.

+  void registerCompileTimeConstant(Constant constant, TreeElements elements) {}
+
+  /// Called during post-processing when [constant] has been evaluated.
+  void registerMetadataConstant(Constant constant, TreeElements elements) {}
+
   /// Called during resolution to notify to the backend that a class is
   /// being instantiated.
   void registerInstantiatedClass(ClassElement cls,
                                  Enqueuer enqueuer,
                                  TreeElements elements) {}
 
   /// Called during resolution to notify to the backend that the
   /// program uses string interpolation.
   void registerStringInterpolation(TreeElements elements) {}
 
@@ skipping 114 matching lines @@
     ClassElement classElement = element.getEnclosingClass();
     return classElement == compiler.objectClass;
   }
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
   Future onLibraryLoaded(LibraryElement library, Uri uri) {
     return new Future.value();
   }
 
-  void registerMetadataInstantiatedType(DartType type, TreeElements elements) {}
-  void registerMetadataStaticUse(Element element) {}
-  void registerMetadataGetOfStaticFunction(FunctionElement element) {}
-
   /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
   /// annotations. The arguments corresponds to the unions of the corresponding
   /// fields of the annotations.
   void registerMirrorUsage(Set<String> symbols,
                            Set<Element> targets,
                            Set<Element> metaTargets) {}
 
   /// Returns true if this element should be retained for reflection even if it
   /// would normally be tree-shaken away.
   bool isNeededForReflection(Element element) => false;
@@ skipping 248 matching lines @@
   ParserTask parser;
   PatchParserTask patchParser;
   LibraryLoader libraryLoader;
   TreeValidatorTask validator;
   ResolverTask resolver;
   closureMapping.ClosureTask closureToClassMapper;
   TypeCheckerTask checker;
   ti.TypesTask typesTask;
   Backend backend;
   ConstantHandler constantHandler;
-  ConstantHandler metadataHandler;
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   String buildId;
 
   static const SourceString MAIN = const SourceString('main');
   static const SourceString CALL_OPERATOR_NAME = const SourceString('call');
   static const SourceString NO_SUCH_METHOD = const SourceString('noSuchMethod');
   static const int NO_SUCH_METHOD_ARG_COUNT = 1;
   static const SourceString CREATE_INVOCATION_MIRROR =
@@ skipping 94 matching lines @@
       resolver = new ResolverTask(this),
       closureToClassMapper = new closureMapping.ClosureTask(this, closureNamer),
       checker = new TypeCheckerTask(this),
       typesTask = new ti.TypesTask(this),
       constantHandler = new ConstantHandler(this, backend.constantSystem),
       deferredLoadTask = new DeferredLoadTask(this),
       mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
       enqueuer = new EnqueueTask(this)];
 
     tasks.addAll(backend.tasks);
-    metadataHandler = new ConstantHandler(
-        this, backend.constantSystem, isMetadata: true);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
 
   bool get analyzeAll => analyzeAllFlag || compileAll;
 
   bool get compileAll => false;
@@ skipping 936 matching lines @@
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }