Use ConstExp for storing constants.

sdk/lib/_internal/compiler/implementation/helpers/trace.dart

 // Copyright (c) 2014, 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.helpers;
 
+/// Function signature for [trace].
+typedef void Trace(String message,
+                   {bool condition(String stackTrace),
+                    int limit,
+                    bool throwOnPrint});
+
 /**
  * Helper method for printing stack traces for debugging.
  *
  * [message] is printed as the header of the stack trace.
  *
  * If [condition] is provided, the stack trace is only printed if [condition]
  * returns [:true:] on the stack trace text. This can be used to filter the
  * printed stack traces based on their content. For instance only print stack
  * traces that contain specific paths.
  *
  * If [limit] is provided, the stack trace is limited to [limit] entries.
  *
  * If [throwOnPrint] is `true`, [message] will be thrown after the stack trace
  * has been printed. Together with [condition] this can be used to discover
  * unknown call-sites in tests by filtering known call-sites and throwning
  * otherwise.
  */
-void trace(String message, {bool condition(String stackTrace), int limit,
-                            bool throwOnPrint: false}) {
+Trace get trace {
+  enableDebugMode();
+  return _trace;
+}
+
+void _trace(String message, {bool condition(String stackTrace), int limit,
+                             bool throwOnPrint: false}) {
   try {
     throw '';
   } catch (e, s) {
     String stackTrace;
     try {
       stackTrace = prettifyStackTrace(
           s, rangeStart: 1, rangeEnd: limit, filePrefix: stackTraceFilePrefix);
     } catch (e) {
       print(e);
       stackTrace = '$s';
     }
     if (condition != null) {
       if (!condition(stackTrace)) return;
     }
     print('$message\n$stackTrace');
     if (throwOnPrint) throw message;
   }
 }
 
-void traceAndReport(Compiler compiler, Spannable node, String message,
-                    {bool condition(String stackTrace), int limit,
-                     bool throwOnPrint: false}) {
+/// Function signature of [traceAndReport].
+typedef void TraceAndReport(Compiler compiler, Spannable node, String message,
+                            {bool condition(String stackTrace), int limit,
+                             bool throwOnPrint});
+
+/// Calls [reportHere] and [trace] with the same message.
+TraceAndReport get traceAndReport {
+  enableDebugMode();
+  return _traceAndReport;
+}
+
+/// Calls [reportHere] and [trace] with the same message.
+TraceAndReport get reportAndTrace => traceAndReport;
+
+/// Implementation of [traceAndReport].
+void _traceAndReport(Compiler compiler, Spannable node, String message,
+                     {bool condition(String stackTrace), int limit,
+                      bool throwOnPrint: false}) {
 
   trace(message, limit: limit, throwOnPrint: throwOnPrint,
         condition: (String stackTrace) {
     bool result = condition != null ? condition(stackTrace) : true;
     if (result) {
       reportHere(compiler, node, message);
     }
     return result;
   });
 }
@@ skipping 240 matching lines @@
   }
   for (int index = text.length ; index < intendedLength ; index ++) {
     int dotsIndex = index % dotsLength;
     sb.write(dots.substring(dotsIndex, dotsIndex + 1));
   }
   if (padLeft) {
     sb.write(text);
   }
   return sb.toString();
 }