Handle const Symbol(...) in kernel_impact

pkg/compiler/lib/src/native/behavior.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.
 
 import '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
-import '../compile_time_constants.dart' show ConstantEnvironment;
-import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/native_data.dart' show NativeData;
 import '../tree/tree.dart';
 import '../universe/side_effects.dart' show SideEffects;
@@ skipping 742 matching lines @@
     _fillNativeBehaviorOfBuiltinOrEmbeddedGlobal(
         behavior, spannable, specString, lookupType, reporter, commonElements,
         validTags: ['returns', 'creates']);
     return behavior;
   }
 
   static NativeBehavior ofMethodElement(
       MethodElement element, Compiler compiler,
       {bool isJsInterop}) {
     ResolutionFunctionType type = element.computeType(compiler.resolution);
-    List<ConstantExpression> metadata = <ConstantExpression>[];
+    List<ConstantValue> metadata = <ConstantValue>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
-      metadata.add(annotation.constant);
+      metadata.add(compiler.constants.getConstantValue(annotation.constant));
     }
 
     BehaviorBuilder builder =
         new ResolverBehaviorBuilder(compiler, compiler.backend.nativeData);
     return builder.buildMethodBehavior(
         type, metadata, lookupFromElement(compiler.resolution, element),
         isJsInterop: isJsInterop);
   }
 
   static NativeBehavior ofFieldElementLoad(
       MemberElement element, Compiler compiler,
       {bool isJsInterop}) {
     Resolution resolution = compiler.resolution;
     ResolutionDartType type = element.computeType(resolution);
-    List<ConstantExpression> metadata = <ConstantExpression>[];
+    List<ConstantValue> metadata = <ConstantValue>[];
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(compiler.resolution);
-      metadata.add(annotation.constant);
+      metadata.add(compiler.constants.getConstantValue(annotation.constant));
     }
 
     BehaviorBuilder builder =
         new ResolverBehaviorBuilder(compiler, compiler.backend.nativeData);
     return builder.buildFieldLoadBehavior(
         type, metadata, lookupFromElement(resolution, element),
         isJsInterop: isJsInterop);
   }
 
   static NativeBehavior ofFieldElementStore(
@@ skipping 39 matching lines @@
         return type;
       }
     }
     return const ResolutionDynamicType();
   }
 }
 
 abstract class BehaviorBuilder {
   CommonElements get commonElements;
   DiagnosticReporter get reporter;
-  ConstantEnvironment get constants;
   NativeData get nativeData;
   bool get trustJSInteropTypeAnnotations;
 
   Resolution get resolution => null;
 
   NativeBehavior _behavior;
 
   void _overrideWithAnnotations(
-      Iterable<ConstantExpression> metadata, TypeLookup lookupType) {
+      Iterable<ConstantValue> metadata, TypeLookup lookupType) {
     if (metadata.isEmpty) return;
 
     List creates =
         _collect(metadata, commonElements.annotationCreatesClass, lookupType);
     List returns =
         _collect(metadata, commonElements.annotationReturnsClass, lookupType);
 
     if (creates != null) {
       _behavior.typesInstantiated
         ..clear()
         ..addAll(creates);
     }
     if (returns != null) {
       _behavior.typesReturned
         ..clear()
         ..addAll(returns);
     }
   }
 
   /**
    * Returns a list of type constraints from the annotations of
    * [annotationClass].
    * Returns `null` if no constraints.
    */
-  List _collect(Iterable<ConstantExpression> metadata,
-      ClassEntity annotationClass, TypeLookup lookupType) {
+  List _collect(Iterable<ConstantValue> metadata, ClassEntity annotationClass,
+      TypeLookup lookupType) {
     var types = null;
-    for (ConstantExpression constant in metadata) {
-      ConstantValue value = constants.getConstantValue(constant);
+    for (ConstantValue value in metadata) {
       if (!value.isConstructedObject) continue;
       ConstructedConstantValue constructedObject = value;
       if (constructedObject.type.element != annotationClass) continue;
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || !fields.single.isString) {
         reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
-            'Annotations needs one string: ${constant.toStructuredText()}');
+            'Annotations needs one string: ${value.toStructuredText()}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       for (final typeString in specString.split('|')) {
         var type = NativeBehavior._parseType(typeString, lookupType);
         if (types == null) types = [];
         types.add(type);
       }
     }
     return types;
@@ skipping 59 matching lines @@
         } else {
           // Otherwise, when the declared type is a Dart type, we do not
           // register an allocation because we assume it cannot be instantiated
           // from within the JS-interop code. It must have escaped from another
           // API.
         }
       }
     }
   }
 
-  NativeBehavior buildFieldLoadBehavior(DartType type,
-      Iterable<ConstantExpression> metadata, TypeLookup lookupType,
+  NativeBehavior buildFieldLoadBehavior(
+      DartType type, Iterable<ConstantValue> metadata, TypeLookup lookupType,
       {bool isJsInterop}) {
     _behavior = new NativeBehavior();
     // TODO(sigmund,sra): consider doing something better for numeric types.
     _behavior.typesReturned.add(!isJsInterop || trustJSInteropTypeAnnotations
         ? type
         : commonElements.dynamicType);
     // Declared types are nullable.
     _behavior.typesReturned.add(commonElements.nullType);
     _capture(type, isInterop: isJsInterop);
     _overrideWithAnnotations(metadata, lookupType);
     return _behavior;
   }
 
   NativeBehavior buildFieldStoreBehavior(DartType type) {
     _behavior = new NativeBehavior();
     _escape(type);
     // We don't override the default behaviour - the annotations apply to
     // loading the field.
     return _behavior;
   }
 
   NativeBehavior buildMethodBehavior(FunctionType type,
-      List<ConstantExpression> metadata, TypeLookup lookupType,
+      Iterable<ConstantValue> metadata, TypeLookup lookupType,
       {bool isJsInterop}) {
     _behavior = new NativeBehavior();
     DartType returnType = type.returnType;
     // Note: For dart:html and other internal libraries we maintain, we can
     // trust the return type and use it to limit what we enqueue. We have to
     // be more conservative about JS interop types and assume they can return
     // anything (unless the user provides the experimental flag to trust the
     // type of js-interop APIs). We do restrict the allocation effects and say
     // that interop calls create only interop types (which may be unsound if
     // an interop call returns a DOM type and declares a dynamic return type,
@@ skipping 27 matching lines @@
   ResolverBehaviorBuilder(this.compiler, this.nativeData);
 
   @override
   CommonElements get commonElements => compiler.commonElements;
 
   @override
   bool get trustJSInteropTypeAnnotations =>
       compiler.options.trustJSInteropTypeAnnotations;
 
   @override
-  ConstantEnvironment get constants => compiler.constants;
-
-  @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
   Resolution get resolution => compiler.resolution;
 }