Remove ConstantExpression.value

pkg/compiler/lib/src/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 219 matching lines @@
       new Uri(scheme: 'dart', path: '_isolate_helper');
   static final Uri DART_HTML =
       new Uri(scheme: 'dart', path: 'html');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
 
   String get patchVersion => USE_NEW_EMITTER ? 'new' : 'old';
 
-  final Annotations annotations = new Annotations();
+  final Annotations annotations;
 
   /// Reference to the internal library to lookup functions to always inline.
   LibraryElement internalLibrary;
 
 
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> get classesRequiredForReflection {
     // TODO(herhut): Clean this up when classes needed for rti are tracked.
     return [closureClass, jsIndexableClass];
@@ skipping 362 matching lines @@
   bool enabledNoSuchMethod = false;
 
   JavaScriptBackend(Compiler compiler,
                     SourceInformationFactory sourceInformationFactory,
                     {bool generateSourceMap: true})
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
+        annotations = new Annotations(compiler),
         super(compiler) {
     emitter = new CodeEmitterTask(compiler, namer, generateSourceMap);
     typeVariableHandler = new TypeVariableHandler(compiler);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = compiler.useCpsIr
          ? new CpsFunctionCompiler(
@@ skipping 331 matching lines @@
         // helper so we register a use of that.
         registry.registerStaticInvocation(getCreateRuntimeType());
       }
     }
   }
 
   void registerMetadataConstant(MetadataAnnotation metadata,
                                 Element annotatedElement,
                                 Registry registry) {
     assert(registry.isForResolution);
-    ConstantValue constant = constants.getConstantForMetadata(metadata).value;
+    ConstantValue constant = constants.getConstantValueForMetadata(metadata);
     registerCompileTimeConstant(constant, registry);
     metadataConstants.add(new Dependency(constant, annotatedElement));
   }
 
   void registerInstantiatedClass(ClassElement cls,
                                  Enqueuer enqueuer,
                                  Registry registry) {
     if (!cls.typeVariables.isEmpty) {
       typeVariableHandler.registerClassWithTypeVariables(cls, enqueuer,
                                                          registry);
@@ skipping 408 matching lines @@
     }
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) {
       return const WorldImpact();
     }
     if (element.isConstructor && element.enclosingClass == jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
       return const WorldImpact();
     }
     if (kind.category == ElementCategory.VARIABLE) {
-      ConstantExpression initialValue =
-          constants.getConstantForVariable(element);
+      ConstantValue initialValue =
+          constants.getConstantValueForVariable(element);
       if (initialValue != null) {
-        registerCompileTimeConstant(initialValue.value, work.registry);
-        constants.addCompileTimeConstantForEmission(initialValue.value);
+        registerCompileTimeConstant(initialValue, work.registry);
+        constants.addCompileTimeConstantForEmission(initialValue);
         // We don't need to generate code for static or top-level
         // variables. For instance variables, we may need to generate
         // the checked setter.
         if (Elements.isStaticOrTopLevel(element)) {
           return const WorldImpact();
         }
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
@@ skipping 529 matching lines @@
     if (name == '') return false;
     return symbolsUsed.contains(name);
   }
 
   bool retainMetadataOf(Element element) {
     if (mustRetainMetadata) hasRetainedMetadata = true;
     if (mustRetainMetadata && referencedFromMirrorSystem(element)) {
       for (MetadataAnnotation metadata in element.metadata) {
         metadata.ensureResolved(compiler);
         ConstantValue constant =
-            constants.getConstantForMetadata(metadata).value;
+            constants.getConstantValueForMetadata(metadata);
         constants.addCompileTimeConstantForEmission(constant);
       }
       return true;
     }
     return false;
   }
 
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == DART_JS_HELPER) {
@@ skipping 263 matching lines @@
    * of a type that is used as a meta target for reflection.
    */
   bool matchesMirrorsMetaTarget(Element element) {
     if (metaTargetsUsed.isEmpty) return false;
     for (Link link = element.metadata; !link.isEmpty; link = link.tail) {
       MetadataAnnotation metadata = link.head;
       // TODO(kasperl): It would be nice if we didn't have to resolve
       // all metadata but only stuff that potentially would match one
       // of the used meta targets.
       metadata.ensureResolved(compiler);
-      ConstantValue value = metadata.constant.value;
+      ConstantValue value =
+          compiler.constants.getConstantValue(metadata.constant);
       if (value == null) continue;
       DartType type = value.getType(compiler.coreTypes);
       if (metaTargetsUsed.contains(type.element)) return true;
     }
     return false;
   }
 
   /**
    * Visits all classes and computes whether its members are needed for
    * reflection.
@@ skipping 277 matching lines @@
     }
 
     LibraryElement library = element.library;
     if (!library.isPlatformLibrary && !library.canUseNative) return;
     bool hasNoInline = false;
     bool hasForceInline = false;
     bool hasNoThrows = false;
     bool hasNoSideEffects = false;
     for (MetadataAnnotation metadata in element.metadata) {
       metadata.ensureResolved(compiler);
-      if (!metadata.constant.value.isConstructedObject) continue;
-      ObjectConstantValue value = metadata.constant.value;
+      ConstantValue constantValue =
+          compiler.constants.getConstantValue(metadata.constant);
+      if (!constantValue.isConstructedObject) continue;
+      ObjectConstantValue value = constantValue;
       ClassElement cls = value.type.element;
       if (cls == forceInlineClass) {
         hasForceInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           compiler.reportHint(element,
               MessageKind.GENERIC,
               {'text': "Must inline"});
         }
         inlineCache.markAsMustInline(element);
       } else if (cls == noInlineClass) {
@@ skipping 114 matching lines @@
       enqueue(enqueuer, getStreamIteratorConstructor(), registry);
     }
   }
 }
 
 /// Handling of special annotations for tests.
 class Annotations {
   static final Uri PACKAGE_EXPECT =
       new Uri(scheme: 'package', path: 'expect/expect.dart');
 
+  final Compiler compiler;
+
   ClassElement expectNoInlineClass;
   ClassElement expectTrustTypeAnnotationsClass;
   ClassElement expectAssumeDynamicClass;
 
+  Annotations(this.compiler);
+
   void onLibraryScanned(LibraryElement library) {
     if (library.canonicalUri == PACKAGE_EXPECT) {
       expectNoInlineClass = library.find('NoInline');
       expectTrustTypeAnnotationsClass = library.find('TrustTypeAnnotations');
       expectAssumeDynamicClass = library.find('AssumeDynamic');
       if (expectNoInlineClass == null ||
           expectTrustTypeAnnotationsClass == null ||
           expectAssumeDynamicClass == null) {
         // This is not the package you're looking for.
         expectNoInlineClass = null;
@@ skipping 19 matching lines @@
   bool assumeDynamic(Element element) {
     return _hasAnnotation(element, expectAssumeDynamicClass);
   }
 
   /// Returns `true` if [element] is annotated with [annotationClass].
   bool _hasAnnotation(Element element, ClassElement annotationClass) {
     if (annotationClass == null) return false;
     for (Link<MetadataAnnotation> link = element.metadata;
          !link.isEmpty;
          link = link.tail) {
-      ConstantValue value = link.head.constant.value;
+      ConstantValue value =
+          compiler.constants.getConstantValue(link.head.constant);
       if (value.isConstructedObject) {
         ConstructedConstantValue constructedConstant = value;
         if (constructedConstant.type.element == annotationClass) {
           return true;
         }
       }
     }
     return false;
   }
 }
@@ skipping 213 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }