Add equivalence check of NativeData and InterceptorData

tests/compiler/dart2js/serialization/model_test_helper.dart

 // Copyright (c) 2015, 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.serialization_model_test;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/constants/values.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/deferred_load.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/enqueue.dart';
 import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/js_backend/js_backend.dart';
 import 'package:compiler/src/js_backend/backend_usage.dart';
+import 'package:compiler/src/js_backend/native_data.dart';
+import 'package:compiler/src/js_backend/interceptor_data.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/tree/nodes.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/util/enumset.dart';
 import 'package:compiler/src/world.dart' show ClosedWorld;
 import '../memory_compiler.dart';
 import 'helper.dart';
 import 'test_data.dart';
 import 'test_helper.dart';
@@ skipping 65 matching lines @@
     checkAllImpacts(compilerNormal, compilerDeserialized, verbose: verbose);
     checkResolutionEnqueuers(
         compilerNormal.backend.backendUsage,
         compilerDeserialized.backend.backendUsage,
         compilerNormal.enqueuer.resolution,
         compilerDeserialized.enqueuer.resolution,
         verbose: verbose);
     checkClosedWorlds(
         compilerNormal.resolutionWorldBuilder.closedWorldForTesting,
         compilerDeserialized.resolutionWorldBuilder.closedWorldForTesting,
-        areElementsEquivalent,
+        // Serialized native data include non-live members.
+        allowExtra: true,
         verbose: verbose);
     checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
   });
 }
 
 void checkResolutionEnqueuers(
     BackendUsage backendUsage1,
     BackendUsage backendUsage2,
     ResolutionEnqueuer enqueuer1,
     ResolutionEnqueuer enqueuer2,
@@ skipping 44 matching lines @@
       "JavaScriptBackend.hasFunctionApplySupport mismatch");
   Expect.equals(
       backendUsage1.isRuntimeTypeUsed,
       backendUsage2.isRuntimeTypeUsed,
       "JavaScriptBackend.hasRuntimeTypeSupport mismatch");
   Expect.equals(backendUsage1.isIsolateInUse, backendUsage2.isIsolateInUse,
       "JavaScriptBackend.hasIsolateSupport mismatch");
 }
 
 void checkClosedWorlds(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
-    bool elementEquivalence(Entity a, Entity b),
-    {bool verbose: false}) {
+    {TestStrategy strategy: const TestStrategy(),
+    bool allowExtra: false,
+    bool verbose: false}) {
   if (verbose) {
     print(closedWorld1.dump());
     print(closedWorld2.dump());
   }
   checkClassHierarchyNodes(
       closedWorld1,
       closedWorld2,
       closedWorld1
           .getClassHierarchyNode(closedWorld1.commonElements.objectClass),
       closedWorld2
           .getClassHierarchyNode(closedWorld2.commonElements.objectClass),
-      elementEquivalence,
+      strategy.elementEquivalence,
+      verbose: verbose);
+
+  checkNativeData(closedWorld1.nativeData, closedWorld2.nativeData,
+      strategy: strategy, allowExtra: allowExtra, verbose: verbose);
+  checkInterceptorData(closedWorld1.interceptorData,
+      closedWorld2.interceptorData, strategy.elementEquivalence,
       verbose: verbose);
 }
 
+void checkNativeData(NativeDataImpl data1, NativeDataImpl data2,
+    {TestStrategy strategy: const TestStrategy(),
+    bool allowExtra: false,
+    bool verbose: false}) {
+  checkMapEquivalence(data1, data2, 'nativeMemberName', data1.nativeMemberName,
+      data2.nativeMemberName, strategy.elementEquivalence, equality,
+      allowExtra: allowExtra);
+
+  checkMapEquivalence(
+      data1,
+      data2,
+      'nativeMethodBehavior',
+      data1.nativeMethodBehavior,
+      data2.nativeMethodBehavior,

[Siggi Cherem (dart-lang), 2017/05/10 16:50:05]

not for this CL, but I keep trying to think of ways in which we can make all of
these "check" functions easier to maintain. Probably not worthwhile?

Here are some ideas:
 1. avoid the duplication with data1 and data2, for example, maybe we can write
the field as a closure:

   checkMapEquivalence(
       data1,
       data2,
      'nativeMethodBehavior',
      (d) => d.nativeMethodBehaviod,
       ...)

 2. create some kind of descriptor for the data that you are checking, and
provide all equivalence functions once with that descriptor? For example:

  var descriptor = new Descritor('native-data')
     ..mapCheck(
         'nativeMethodBehavior',
         (d) => d.nativeMethodBehavior.
         keysType: Entity,
         valuesType: NativeBehavior),
     ..mapCheck(
         'nativeFieldLoadBehavior',
         (d) => d.nativeFieldLoadBehavior));


  runChecks(descriptor, data1, data2, {
     Entity: strategy.elementEquivalence,
     NativeBehavior: testNativeBehavior
  });

 3. even further - we could use mirrors or a code generator to make this more
succinct. With mirrors we would declare this descriptor using metadata, for
example:

   class NativeDataEquivalenceChecks extends EquivalenceChecks {
      NativeData data;
      NativeDataEquivalenceChecks(this.data);

      @Check.map(Entity, NativeBehavior)
      get nativeMethodBehavior => data.nativeMethodBehavior;

      @Check.set(Entity)
      get anonymousJsInteropClasses => data.jsInteropClasses;

      ..
   }

[Johnni Winther, 2017/05/11 12:01:32]

Acknowledged.

+      strategy.elementEquivalence,
+      (a, b) => testNativeBehavior(a, b, strategy: strategy),
+      allowExtra: allowExtra);
+
+  checkMapEquivalence(
+      data1,
+      data2,
+      'nativeFieldLoadBehavior',
+      data1.nativeFieldLoadBehavior,
+      data2.nativeFieldLoadBehavior,
+      strategy.elementEquivalence,
+      (a, b) => testNativeBehavior(a, b, strategy: strategy),
+      allowExtra: allowExtra);
+
+  checkMapEquivalence(
+      data1,
+      data2,
+      'nativeFieldStoreBehavior',
+      data1.nativeFieldStoreBehavior,
+      data2.nativeFieldStoreBehavior,
+      strategy.elementEquivalence,
+      (a, b) => testNativeBehavior(a, b, strategy: strategy),
+      allowExtra: allowExtra);
+
+  checkMapEquivalence(
+      data1,
+      data2,
+      'jsInteropLibraryNames',
+      data1.jsInteropLibraryNames,
+      data2.jsInteropLibraryNames,
+      strategy.elementEquivalence,
+      equality);
+
+  checkSetEquivalence(
+      data1,
+      data2,
+      'anonymousJsInteropClasses',
+      data1.anonymousJsInteropClasses,
+      data2.anonymousJsInteropClasses,
+      strategy.elementEquivalence);
+
+  checkMapEquivalence(
+      data1,
+      data2,
+      'jsInteropClassNames',
+      data1.jsInteropClassNames,
+      data2.jsInteropClassNames,
+      strategy.elementEquivalence,
+      equality);
+
+  checkMapEquivalence(
+      data1,
+      data2,
+      'jsInteropMemberNames',
+      data1.jsInteropMemberNames,
+      data2.jsInteropMemberNames,
+      strategy.elementEquivalence,
+      equality);
+}
+
+void checkInterceptorData(InterceptorDataImpl data1, InterceptorDataImpl data2,
+    bool elementEquivalence(Entity a, Entity b),
+    {bool verbose: false}) {
+  checkMapEquivalence(
+      data1,
+      data2,
+      'interceptedElements',
+      data1.interceptedElementsForTesting,
+      data2.interceptedElementsForTesting,
+      equality,
+      (a, b) => areSetsEquivalent(a, b, elementEquivalence));
+
+  checkSetEquivalence(data1, data2, 'interceptedClasses',
+      data1.interceptedClasses, data2.interceptedClasses, elementEquivalence);
+
+  checkSetEquivalence(
+      data1,
+      data2,
+      'classesMixedIntoInterceptedClasses',
+      data1.classesMixedIntoInterceptedClassesForTesting,
+      data2.classesMixedIntoInterceptedClassesForTesting,
+      elementEquivalence);
+}
+
 void checkBackendInfo(Compiler compilerNormal, Compiler compilerDeserialized,
     {bool verbose: false}) {
   checkSets(
       compilerNormal.enqueuer.resolution.processedEntities,
       compilerDeserialized.enqueuer.resolution.processedEntities,
       "Processed element mismatch",
       areElementsEquivalent, onSameElement: (a, b) {
     checkElements(compilerNormal, compilerDeserialized, a, b, verbose: verbose);
   }, verbose: verbose);
   Expect.equals(
@@ skipping 272 matching lines @@
 }
 
 bool areInstancesEquivalent(Instance instance1, Instance instance2,
     bool typeEquivalence(DartType a, DartType b)) {
   InterfaceType type1 = instance1.type;
   InterfaceType type2 = instance2.type;
   return typeEquivalence(type1, type2) &&
       instance1.kind == instance2.kind &&
       instance1.isRedirection == instance2.isRedirection;
 }