Use the entity model for dump_info.

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 '../../compiler_new.dart' as api;
 import '../common.dart';
-import '../common_elements.dart';
 import '../common/backend_api.dart';
 import '../common/names.dart';
 import '../common/resolution.dart';
 import '../common/tasks.dart';
 import '../common/work.dart';
+import '../common_elements.dart';
 import '../compiler.dart';
+import '../constants/expressions.dart' show ConstantExpression;
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
+import '../enqueue.dart';
 import '../environment.dart';
-import '../enqueue.dart';
 import '../frontend_strategy.dart';
 import '../js_backend/backend.dart';
 import '../js_backend/backend_usage.dart';
 import '../js_backend/interceptor_data.dart';
 import '../js_backend/mirrors_analysis.dart';
 import '../js_backend/mirrors_data.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../js_backend/runtime_types.dart';
 import '../library_loader.dart';
 import '../native/enqueue.dart' show NativeResolutionEnqueuer;
 import '../native/resolver.dart';
 import '../options.dart';
-import '../tree/tree.dart' show Node;
-import '../serialization/task.dart';
 import '../patch_parser.dart';
 import '../resolved_uri_translator.dart';
+import '../serialization/task.dart';
+import '../tree/tree.dart' show Node;
 import '../universe/call_structure.dart';
 import '../universe/use.dart';
 import '../universe/world_builder.dart';
 import '../universe/world_impact.dart';
 import 'no_such_method_resolver.dart';
 
 /// [FrontendStrategy] that loads '.dart' files and creates a resolved element
 /// model using the resolver.
 class ResolutionFrontEndStrategy extends FrontendStrategyBase
     with ComputeSpannableMixin {
@@ skipping 457 matching lines @@
       MemberElement member = _member;
       if (member.isSynthesized) return;
       if (member.isMalformed) return;
       if (member.isConstructor) return;
       f(declarer, member);
     }, includeSuperAndInjectedMembers: true);
   }
 
   @override
   void forEachConstructor(
-      covariant ClassElement cls, void f(ConstructorEntity constructor)) {
-    cls.ensureResolved(_resolution);
+      covariant ClassElement cls, void f(ConstructorEntity constructor),
+      {bool ensureResolved: true}) {
+    if (ensureResolved) cls.ensureResolved(_resolution);
     for (ConstructorElement constructor in cls.implementation.constructors) {
-      _resolution.ensureResolved(constructor.declaration);
+      if (ensureResolved) _resolution.ensureResolved(constructor.declaration);
       if (constructor.isRedirectingFactory) continue;
       f(constructor);
     }
   }
 
   @override
   void forEachConstructorBody(
       covariant ClassElement cls, void f(ConstructorBodyEntity constructor)) {
     cls.forEachConstructorBody(f);
   }
 
   @override
+  void forEachNestedClosure(
+      covariant MemberElement member, void f(FunctionEntity closure)) {
+    for (var closure in member.nestedClosures) {
+      f(closure);
+    }
+  }
+
+  @override
   ClassEntity getSuperClass(covariant ClassElement cls,
       {bool skipUnnamedMixinApplications: false}) {
     cls.ensureResolved(_resolution);
     ClassElement superclass = cls.superclass;
     if (skipUnnamedMixinApplications) {
       while (superclass != null && superclass.isUnnamedMixinApplication) {
         superclass = superclass.superclass;
       }
     }
     return superclass;
@@ skipping 127 matching lines @@
     return field.type;
   }
 
   @override
   ResolutionFunctionType getLocalFunctionType(
       covariant LocalFunctionElement function) {
     return function.type;
   }
 
   @override
+  ConstantExpression getFieldConstant(covariant FieldElement field) {
+    return field.constant;
+  }
+
+  @override
   ResolutionDartType getUnaliasedType(covariant ResolutionDartType type) {
     type.computeUnaliased(_resolution);
     return type.unaliased;
   }
 
   @override
   Iterable<ConstantValue> getMemberMetadata(covariant MemberElement element,
       {bool includeParameterMetadata: false}) {
     List<ConstantValue> values = <ConstantValue>[];
     values.addAll(_getMetadataOf(element));
@@ skipping 34 matching lines @@
       }
     });
     return constants;
   }
 
   @override
   ResolutionFunctionType getFunctionTypeOfTypedef(
       covariant TypedefElement typedef) {
     return typedef.alias;
   }
+
+  @override
+  bool hasBeenResolved(covariant Element element) {
+    return _compiler.resolution.hasBeenResolved(element);
+  }
+
+  @override
+  bool hasClassBeenResolved(covariant ClassElement cls) {
+    return cls.isResolved;
+  }
 }
 
 /// AST-based logic for processing annotations. These annotations are processed
 /// very early in the compilation pipeline, typically this is before resolution
 /// is complete. Because of that this processor does a lightweight parse of the
 /// annotation (which is restricted to a limited subset of the annotation
 /// syntax), and, once resolution completes, it validates that the parsed
 /// annotations correspond to the correct element.
 class _ElementAnnotationProcessor implements AnnotationProcessor {
   final Compiler _compiler;
@@ skipping 211 matching lines @@
 
   @override
   void forEachConstructor(
       covariant ClassElement cls, void f(ConstructorEntity constructor)) {
     cls.constructors.forEach((Element _constructor) {
       ConstructorElement constructor = _constructor;
       f(constructor);
     });
   }
 }