Handle private dynamic access in impact_test.

pkg/compiler/lib/src/serialization/equivalence.dart

 // Copyright (c) 2016, 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.
 
 /// Functions for asserting equivalence across serialization.
 
 library dart2js.serialization.equivalence;
 
 import '../closure.dart';
 import '../common/resolution.dart';
@@ skipping 132 matching lines @@
   return areListsEquivalent(a, b, areConstantsEquivalent);
 }
 
 /// Returns `true` if the lists of constant values, [a] and [b], are equivalent.
 bool areConstantValueListsEquivalent(
     List<ConstantValue> a, List<ConstantValue> b) {
   return areListsEquivalent(a, b, areConstantValuesEquivalent);
 }
 
 /// Returns `true` if the selectors [a] and [b] are equivalent.
-bool areSelectorsEquivalent(Selector a, Selector b) {
+bool areSelectorsEquivalent(Selector a, Selector b,
+    {TestStrategy strategy: const TestStrategy()}) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
   return a.kind == b.kind &&
       a.callStructure == b.callStructure &&
-      areNamesEquivalent(a.memberName, b.memberName);
+      areNamesEquivalent(a.memberName, b.memberName, strategy: strategy);
 }
 
 /// Returns `true` if the names [a] and [b] are equivalent.
-bool areNamesEquivalent(Name a, Name b) {
-  LibraryElement library1 = a.library;
-  LibraryElement library2 = b.library;
+bool areNamesEquivalent(Name a, Name b,
+    {TestStrategy strategy: const TestStrategy()}) {
   return a.text == b.text &&
       a.isSetter == b.isSetter &&
-      areElementsEquivalent(library1, library2);
+      strategy.testElements(a, b, 'library', a.library, b.library);
 }
 
 /// Returns `true` if the dynamic uses [a] and [b] are equivalent.
-bool areDynamicUsesEquivalent(DynamicUse a, DynamicUse b) {
-  return areSelectorsEquivalent(a.selector, b.selector);
+bool areDynamicUsesEquivalent(DynamicUse a, DynamicUse b,
+    {TestStrategy strategy: const TestStrategy()}) {
+  return areSelectorsEquivalent(a.selector, b.selector, strategy: strategy);
 }
 
 /// Returns `true` if the static uses [a] and [b] are equivalent.
 bool areStaticUsesEquivalent(StaticUse a, StaticUse b,
     {TestStrategy strategy: const TestStrategy()}) {
   return a.kind == b.kind &&
       strategy.testElements(a, b, 'element', a.element, b.element);
 }
 
 /// Returns `true` if the type uses [a] and [b] are equivalent.
@@ skipping 836 matching lines @@
     {TestStrategy strategy = const TestStrategy()}) {
   return strategy.testSets(impact1, impact2, 'constSymbolNames',
           impact1.constSymbolNames, impact2.constSymbolNames) &&
       strategy.testSets(
           impact1,
           impact2,
           'constantLiterals',
           impact1.constantLiterals,
           impact2.constantLiterals,
           areConstantsEquivalent) &&
-      strategy.testSets(impact1, impact2, 'dynamicUses', impact1.dynamicUses,
-          impact2.dynamicUses, areDynamicUsesEquivalent) &&
+      strategy.testSets(
+          impact1,
+          impact2,
+          'dynamicUses',
+          impact1.dynamicUses,
+          impact2.dynamicUses,
+          (a, b) =>
+              areDynamicUsesEquivalent(a, b, strategy: strategy.testOnly)) &&
       strategy.testSets(
           impact1, impact2, 'features', impact1.features, impact2.features) &&
       strategy.testSets(
           impact1,
           impact2,
           'listLiterals',
           impact1.listLiterals,
           impact2.listLiterals,
           (a, b) => areListLiteralUsesEquivalent(a, b,
               strategy: strategy.testOnly)) &&
@@ skipping 1062 matching lines @@
 }
 
 bool areMetadataAnnotationsEquivalent(
     MetadataAnnotation metadata1, MetadataAnnotation metadata2) {
   if (metadata1 == metadata2) return true;
   if (metadata1 == null || metadata2 == null) return false;
   return areElementsEquivalent(
           metadata1.annotatedElement, metadata2.annotatedElement) &&
       areConstantsEquivalent(metadata1.constant, metadata2.constant);
 }