Register literals through backend.

dart/pkg/compiler/lib/src/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 506 matching lines @@
   FunctionElement helperForBadMain() => null;
 
   FunctionElement helperForMissingMain() => null;
 
   FunctionElement helperForMainArity() => null;
 
   void forgetElement(Element element) {}
 
   void registerMainHasArguments(Enqueuer enqueuer) {}
 
-  void registerAsyncMarker(FunctionElement element,
-                             Enqueuer enqueuer,
-                             Registry registry) {}
+  void registerAsyncMarker(
+      FunctionElement element,
+      Enqueuer enqueuer,
+      Registry registry) {}
 }
 
 /// Backend callbacks function specific to the resolution phase.
 class ResolutionCallbacks {
   /// Register that [node] is a call to `assert`.
   void onAssert(Send node, Registry registry) {}
 
   /// Called during resolution to notify to the backend that the
   /// program uses string interpolation.
   void onStringInterpolation(Registry registry) {}
@@ skipping 46 matching lines @@
 
   /// Register that a super call will end up calling
   /// [: super.noSuchMethod :].
   void onSuperNoSuchMethod(Registry registry) {}
 
   /// Register that the application creates a constant map.
   void onConstantMap(Registry registry) {}
 
   /// Called when resolving the `Symbol` constructor.
   void onSymbolConstructor(Registry registry) {}
+
+  /// Called when resolving a literal int.
+  void onLiteralInt(Registry registry) {}
+
+  /// Called when resolving a literal double.
+  void onLiteralDouble(Registry registry) {}
+
+  /// Called when resolving a literal bool.
+  void onLiteralBool(Registry registry) {}
+
+  /// Called when resolving a literal String.
+  void onLiteralString(Registry registry) {}
+
+  /// Called when resolving a literal null.
+  void onLiteralNull(Registry registry) {}
+
+  /// Called when resolving a literal Symbol.
+  void onLiteralSymbol(Registry registry) {}
+
+  /// Called when resolving a literal Function (aka a closure).
+  void onLiteralFunction(Registry registry) {}
 }
 
 /**
  * Key class used in [TokenMap] in which the hash code for a token is based
  * on the [charOffset].
  */
 class TokenKey {
   final Token token;
   TokenKey(this.token);
   int get hashCode => token.charOffset;
@@ skipping 1793 matching lines @@
     return futureClass.computeType(compiler).createInstantiation([elementType]);
   }
 
   @override
   InterfaceType streamType([DartType elementType = const DynamicType()]) {
     return streamClass.computeType(compiler).createInstantiation([elementType]);
   }
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);