Use entities in most of MirrorsData

pkg/compiler/lib/src/resolution/resolution_strategy.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.resolution_strategy;
 
 import 'package:front_end/src/fasta/scanner.dart' show Token;
 
 import '../common.dart';
 import '../common_elements.dart';
@@ skipping 90 matching lines @@
         _compiler.reporter,
         elementEnvironment,
         commonElements,
         nativeBasicData);
   }
 
   NoSuchMethodResolver createNoSuchMethodResolver() =>
       new ResolutionNoSuchMethodResolver();
 
   MirrorsDataBuilder createMirrorsDataBuilder() {
-    return new MirrorsDataImpl(_compiler, _compiler.options, commonElements);
+    return new MirrorsDataImpl(
+        _compiler, _compiler.options, elementEnvironment, commonElements);
   }
 
   MirrorsResolutionAnalysis createMirrorsResolutionAnalysis(
           JavaScriptBackend backend) =>
       new MirrorsResolutionAnalysisImpl(backend, _compiler.resolution);
 
   RuntimeTypesNeedBuilder createRuntimeTypesNeedBuilder() {
     return new ResolutionRuntimeTypesNeedBuilderImpl(
         elementEnvironment, dartTypes);
   }
@@ skipping 535 matching lines @@
     return function.type;
   }
 
   @override
   ResolutionDartType getUnaliasedType(covariant ResolutionDartType type) {
     type.computeUnaliased(_resolution);
     return type.unaliased;
   }
 
   @override
-  Iterable<ConstantValue> getMemberMetadata(covariant MemberElement element) {
+  Iterable<ConstantValue> getMemberMetadata(covariant MemberElement element,
+      {bool includeParameterMetadata: false}) {
     List<ConstantValue> values = <ConstantValue>[];
+    values.addAll(_getMetadataOf(element));
+    if (includeParameterMetadata) {
+      if (element.isFunction || element.isConstructor || element.isSetter) {
+        MethodElement function = element.implementation;
+        function.functionSignature.forEachParameter(
+            (parameter) => values.addAll(_getMetadataOf(parameter)));
+      }
+    }
+    return values;
+  }
+
+  @override
+  Iterable<ConstantValue> getLibraryMetadata(covariant LibraryElement element) {
+    return _getMetadataOf(element);
+  }
+
+  @override
+  Iterable<ConstantValue> getClassMetadata(covariant ClassElement element) {
+    return _getMetadataOf(element);
+  }
+
+  @override
+  Iterable<ConstantValue> getTypedefMetadata(covariant TypedefElement element) {
+    return _getMetadataOf(element);
+  }
+
+  Iterable<ConstantValue> _getMetadataOf(Element element) {
+    List<ConstantValue> constants = <ConstantValue>[];
     _compiler.reporter.withCurrentElement(element, () {
       for (MetadataAnnotation metadata in element.implementation.metadata) {
         metadata.ensureResolved(_compiler.resolution);
         assert(metadata.constant != null,
             failedAt(metadata, "Unevaluated metadata constant."));
-        ConstantValue value =
-            _compiler.constants.getConstantValue(metadata.constant);
-        values.add(value);
+        constants.add(
+            _compiler.backend.constants.getConstantValue(metadata.constant));
       }
     });
-    return values;
+    return constants;
   }
 
   @override
   ResolutionFunctionType getFunctionTypeOfTypedef(
       covariant TypedefElement typedef) {
     return typedef.alias;
   }
 }
 
 /// AST-based logic for processing annotations. These annotations are processed
@@ skipping 197 matching lines @@
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(element.isDeclaration, failedAt(element));
     if (element.isMalformed) return null;
 
     assert(element is AnalyzableElement,
         failedAt(element, 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }