Use ConstExp for storing 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 1182 matching lines @@
   /// The method returns a [Future] allowing for the loading of additional
   /// libraries.
   Future onLibrariesLoaded(Map<Uri, LibraryElement> loadedLibraries) {
     return new Future.sync(() {
       if (!loadedLibraries.containsKey(DART_CORE)) return new Future.value();
 
       functionClass.ensureResolved(this);
       functionApplyMethod = functionClass.lookupLocalMember('apply');
 
       proxyConstant =
-          resolver.constantCompiler.compileConstant(coreLibrary.find('proxy'));
+          resolver.constantCompiler.compileConstant(
+              coreLibrary.find('proxy')).value;
 
       // TODO(johnniwinther): Move this to the JavaScript backend.
       LibraryElement jsHelperLibrary =
           loadedLibraries[js_backend.JavaScriptBackend.DART_JS_HELPER];
       if (jsHelperLibrary != null) {
         patchConstant = resolver.constantCompiler.compileConstant(
-            jsHelperLibrary.find('patch'));
+            jsHelperLibrary.find('patch')).value;
       }
 
       if (preserveComments) {
         return libraryLoader.loadLibrary(DART_MIRRORS)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
@@ skipping 43 matching lines @@
     numClass = lookupCoreClass('num');
     intClass = lookupCoreClass('int');
     doubleClass = lookupCoreClass('double');
     stringClass = lookupCoreClass('String');
     functionClass = lookupCoreClass('Function');
     listClass = lookupCoreClass('List');
     typeClass = lookupCoreClass('Type');
     mapClass = lookupCoreClass('Map');
     nullClass = lookupCoreClass('Null');
     stackTraceClass = lookupCoreClass('StackTrace');
+    symbolClass = lookupCoreClass('Symbol');
     if (!missingCoreClasses.isEmpty) {
       internalError(coreLibrary,
           'dart:core library does not contain required classes: '
           '$missingCoreClasses');
     }
-
-    // The Symbol class may not exist during unit testing.
-    // TODO(ahe): It is possible that we have to require the presence
-    // of Symbol as we change how we implement noSuchMethod.
-    symbolClass = lookupCoreClass('Symbol');
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
     Selector callConstructor = new Selector.callConstructor(
         "", listClass.library);
     return _unnamedListConstructor =
         listClass.lookupConstructor(callConstructor);
   }
@@ skipping 766 matching lines @@
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }
 
+/// Flag that can be used in assertions to assert that a code path is only
+/// executed as part of development.
+///
+/// This flag is automatically set to true if helper methods like, [debugPrint],
+/// [debugWrapPrint], [trace], and [reportHere] are called.
+bool DEBUG_MODE = false;
+
+/// Assert that [DEBUG_MODE] is `true` and provide [message] as part of the
+/// error message.
+assertDebugMode(String message) {
+  assert(invariant(NO_LOCATION_SPANNABLE, DEBUG_MODE,
+      message: 'Debug mode is not enabled: $message'));
+}
+
 /**
  * Throws a [SpannableAssertionFailure] if [condition] is
  * [:false:]. [condition] must be either a [:bool:] or a no-arg
  * function returning a [:bool:].
  *
  * Use this method to provide better information for assertion by calling
  * [invariant] as the argument to an [:assert:] statement:
  *
  *     assert(invariant(position, isValid));
  *
@@ skipping 12 matching lines @@
   }
   if (!condition) {
     if (message is Function) {
       message = message();
     }
     throw new SpannableAssertionFailure(spannable, message);
   }
   return true;
 }
 
-/**
- * Global
- */
+/// Returns `true` when [s] is private if used as an identifier.
 bool isPrivateName(String s) => !s.isEmpty && s.codeUnitAt(0) == $_;
 
 /// A sink that drains into /dev/null.
 class NullSink implements EventSink<String> {
   final String name;
 
   NullSink(this.name);
 
   add(String value) {}
 
@@ skipping 14 matching lines @@
   int warnings = 0;
   int hints = 0;
 }
 
 class GenericTask extends CompilerTask {
   final String name;
 
   GenericTask(this.name, Compiler compiler)
       : super(compiler);
 }