Test ResolutionImpact equivalence.

pkg/compiler/lib/src/common/resolution.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.
 
 library dart2js.common.resolution;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
@@ skipping 127 matching lines @@
   }
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! MapLiteralUse) return false;
     return
         type == other.type &&
         isConstant == other.isConstant &&
         isEmpty == other.isEmpty;
   }
+
+  String toString() {
+    return 'MapLiteralUse($type,isConstant:$isConstant,isEmpty:$isEmpty)';
+  }
 }
 
 /// A use of a list literal seen during resolution.
 class ListLiteralUse {
   final InterfaceType type;
   final bool isConstant;
   final bool isEmpty;
 
   ListLiteralUse(this.type, {this.isConstant: false, this.isEmpty: false});
 
   int get hashCode {
     return
         type.hashCode * 13 +
         isConstant.hashCode * 17 +
         isEmpty.hashCode * 19;
   }
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! ListLiteralUse) return false;
     return
         type == other.type &&
         isConstant == other.isConstant &&
         isEmpty == other.isEmpty;
   }
+
+  String toString() {
+    return 'ListLiteralUse($type,isConstant:$isConstant,isEmpty:$isEmpty)';
+  }
 }
 
 // TODO(johnniwinther): Rename to `Resolver` or `ResolverContext`.
 abstract class Resolution {
   Parsing get parsing;
   DiagnosticReporter get reporter;
   CoreTypes get coreTypes;
 
+  bool retainCaches;
+
   void resolveTypedef(TypedefElement typdef);
   void resolveClass(ClassElement cls);
   void registerClass(ClassElement cls);
   void resolveMetadataAnnotation(MetadataAnnotation metadataAnnotation);
   FunctionSignature resolveSignature(FunctionElement function);
   DartType resolveTypeAnnotation(Element element, TypeAnnotation node);
 
   bool hasBeenResolved(Element element);
 
   ResolutionWorkItem createWorkItem(
       Element element, ItemCompilationContext compilationContext);
 
+  /// Returns `true` if the [ResolutionImpact] for [element] is cached.
+  bool hasResolutionImpact(Element element);
+
   /// Returns the precomputed [ResolutionImpact] for [element].
   ResolutionImpact getResolutionImpact(Element element);
 
   /// Returns the precomputed [WorldImpact] for [element].
   WorldImpact getWorldImpact(Element element);
 
   /// Computes the [WorldImpact] for [element].
   WorldImpact computeWorldImpact(Element element);
 
   /// Removes the [WorldImpact] for [element] from the resolution cache. Later
   /// calls to [getWorldImpact] or [computeWorldImpact] returns an empty impact.
   void uncacheWorldImpact(Element element);
 
   /// Removes the [WorldImpact]s for all [Element]s in the resolution cache. ,
   /// Later calls to [getWorldImpact] or [computeWorldImpact] returns an empty
   /// impact.
   void emptyCache();
 }
 
 // TODO(johnniwinther): Rename to `Parser` or `ParsingContext`.
 abstract class Parsing {
   DiagnosticReporter get reporter;
   void parsePatchClass(ClassElement cls);
   measure(f());
   ScannerOptions getScannerOptionsFor(Element element);
 }