Handle const Symbol(...) in kernel_impact

pkg/compiler/lib/src/kernel/element_map.dart

 // Copyright (c) 2017, 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.
 
 library dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 59 matching lines @@
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelToElementMap(this.reporter) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this);
-    _nativeBehaviorBuilder =
-        new KernelBehaviorBuilder(_commonElements, _constantEnvironment);
+    _nativeBehaviorBuilder = new KernelBehaviorBuilder(_commonElements);
     _types = new _KernelDartTypes(this);
     _typeConverter = new DartTypeConverter(this);
   }
 
   /// Adds libraries in [program] to the set of libraries.
   ///
   /// The main method of the first program is used as the main method for the
   /// compilation.
   void addProgram(ir.Program program) {
     _env.addProgram(program);
@@ skipping 25 matching lines @@
   @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
   ConstantEnvironment get constantEnvironment => _constantEnvironment;
 
   DartTypes get types => _types;
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
 
+  @override
+  ConstantValue computeConstantValue(ConstantExpression constant) {
+    return _constantEnvironment.getConstantValue(constant);
+  }
+
   LibraryEntity lookupLibrary(Uri uri) {
     _KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   KLibrary _getLibrary(ir.Library node, [_KLibraryEnv libraryEnv]) {
     return _libraryMap.putIfAbsent(node, () {
       Uri canonicalUri = node.importUri;
       _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(canonicalUri));
@@ skipping 50 matching lines @@
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
       return new KClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
     });
   }
 
-  Iterable<ConstantExpression> _getClassMetadata(KClass cls) {
+  Iterable<ConstantValue> _getClassMetadata(KClass cls) {
     return _classEnvs[cls.classIndex].getMetadata(this);
   }
 
   KTypeVariable _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
         return new KTypeVariable(_getClass(cls), node.name, index);
       }
@@ skipping 517 matching lines @@
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
   InterfaceType mixedInType;
   OrderedTypeSet orderedTypeSet;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
-  Iterable<ConstantExpression> _metadata;
+  Iterable<ConstantValue> _metadata;
 
   _KClassEnv(this.cls)
       // TODO(johnniwinther): Change this to use a property on [cls] when such
       // is added to kernel.
       : isUnnamedMixinApplication = cls.name.contains('+');
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _setterMap = <String, ir.Member>{};
@@ skipping 48 matching lines @@
     _memberMap.values.forEach(f);
     for (ir.Member member in _setterMap.values) {
       if (member is ir.Procedure) {
         f(member);
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 
-  Iterable<ConstantExpression> getMetadata(KernelToElementMap elementMap) {
+  Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap) {
     if (_metadata == null) {
       _metadata = elementMap.getMetadata(cls.annotations);
     }
     return _metadata;
   }
 }
 
 class _MemberData {
   final ir.Member node;
-  Iterable<ConstantExpression> _metadata;
+  Iterable<ConstantValue> _metadata;
 
   _MemberData(this.node);
 
   ResolutionImpact getWorldImpact(KernelToElementMap elementMap) {
     return buildKernelImpact(node, elementMap);
   }
 
-  Iterable<ConstantExpression> getMetadata(KernelToElementMap elementMap) {
+  Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap) {
     return _metadata ??= elementMap.getMetadata(node.annotations);
   }
 }
 
 class _FunctionData extends _MemberData {
   final ir.FunctionNode functionNode;
   FunctionType _type;
   CallStructure _callStructure;
 
   _FunctionData(ir.Member node, this.functionNode) : super(node);
@@ skipping 209 matching lines @@
   }
 
   @override
   bool isDeferredLoadLibraryGetter(KMember member) {
     // TODO(johnniwinther): Support these.
     return false;
   }
 
   @override
   Iterable<ConstantValue> getMemberMetadata(KMember member) {
-    List<ConstantValue> values = <ConstantValue>[];
     _MemberData memberData = elementMap._memberList[member.memberIndex];
-    for (ConstantExpression constant in memberData.getMetadata(elementMap)) {
-      values.add(elementMap.constantEnvironment.getConstantValue(constant));
-    }
-    return values;
+    return memberData.getMetadata(elementMap);
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelToElementMap elementAdapter;
   bool topLevel = true;
 
   DartTypeConverter(this.elementAdapter);
 
@@ skipping 61 matching lines @@
           "Outermost invalid types not currently supported");
     }
     // Nested invalid types are treated as `dynamic`.
     return const DynamicType();
   }
 }
 
 /// [native.BehaviorBuilder] for kernel based elements.
 class KernelBehaviorBuilder extends native.BehaviorBuilder {
   final CommonElements commonElements;
-  final ConstantEnvironment constants;
 
-  KernelBehaviorBuilder(
-    this.commonElements,
-    this.constants,
-  );
+  KernelBehaviorBuilder(this.commonElements);
 
   @override
   bool get trustJSInteropTypeAnnotations {
     throw new UnimplementedError(
         "KernelNativeBehaviorComputer.trustJSInteropTypeAnnotations");
   }
 
   @override
   DiagnosticReporter get reporter {
     throw new UnimplementedError("KernelNativeBehaviorComputer.reporter");
@@ skipping 139 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     _KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }