Less inequivalence on Hello World!

tests/compiler/dart2js/equivalence/check_functions.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.
 
 /// Equivalence test functions for data objects.
 
 library dart2js.equivalence.functions;
 
 import 'package:expect/expect.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/common_elements.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/types.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/js_backend/backend_usage.dart';
 import 'package:compiler/src/js_backend/enqueuer.dart';
 import 'package:compiler/src/js_backend/native_data.dart';
 import 'package:compiler/src/js_backend/interceptor_data.dart';
+import 'package:compiler/src/js_emitter/code_emitter_task.dart';
+import 'package:compiler/src/js_emitter/model.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/world.dart';
 import 'check_helpers.dart';
 
 void checkClosedWorlds(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
     {TestStrategy strategy: const TestStrategy(),
     bool allowExtra: false,
     bool verbose: false,
@@ skipping 595 matching lines @@
 
 bool _areEntitiesEquivalent(a, b) => areElementsEquivalent(a, b);
 
 void checkResolutionEnqueuers(
     BackendUsage backendUsage1,
     BackendUsage backendUsage2,
     ResolutionEnqueuer enqueuer1,
     ResolutionEnqueuer enqueuer2,
     {bool elementEquivalence(Entity a, Entity b): _areEntitiesEquivalent,
     bool typeEquivalence(DartType a, DartType b): areTypesEquivalent,
-    bool elementFilter(Element element),
+    bool elementFilter(Entity element),
     bool verbose: false,
     bool skipClassUsageTesting: false}) {
   elementFilter ??= (_) => true;
 
   ResolutionWorldBuilderBase worldBuilder1 = enqueuer1.worldBuilder;
   ResolutionWorldBuilderBase worldBuilder2 = enqueuer2.worldBuilder;
 
   checkSets(worldBuilder1.instantiatedTypes, worldBuilder2.instantiatedTypes,
       "Instantiated types mismatch", typeEquivalence,
       verbose: verbose);
@@ skipping 142 matching lines @@
       areAbstractUsagesEquivalent,
       verbose: verbose);
   checkMaps(
       worldBuilder1.instanceMemberUsageForTesting,
       worldBuilder2.instanceMemberUsageForTesting,
       'instanceMemberUsageForTesting',
       elementEquivalence,
       areAbstractUsagesEquivalent,
       verbose: verbose);
 }
+
+// TODO(johnniwinther): Check all emitter properties.
+void checkEmitters(CodeEmitterTask emitter1, CodeEmitterTask emitter2,
+    {bool elementEquivalence(Entity a, Entity b): _areEntitiesEquivalent,
+    bool typeEquivalence(DartType a, DartType b): areTypesEquivalent,
+    bool elementFilter(Element element),
+    bool verbose: false}) {
+  checkPrograms(
+      emitter1.emitter.programForTesting, emitter2.emitter.programForTesting);
+
+  checkSets(
+      emitter1.typeTestRegistry.rtiNeededClasses,
+      emitter2.typeTestRegistry.rtiNeededClasses,
+      "TypeTestRegistry rti needed classes mismatch",
+      elementEquivalence,
+      verbose: verbose);
+
+  checkSets(
+      emitter1.typeTestRegistry.checkedFunctionTypes,
+      emitter2.typeTestRegistry.checkedFunctionTypes,
+      "TypeTestRegistry checked function types mismatch",
+      typeEquivalence,
+      verbose: verbose);
+
+  checkSets(
+      emitter1.typeTestRegistry.checkedClasses,
+      emitter2.typeTestRegistry.checkedClasses,
+      "TypeTestRegistry checked classes mismatch",
+      elementEquivalence,
+      verbose: verbose);
+}
+
+// TODO(johnniwinther): Check all program properties.
+void checkPrograms(Program program1, Program program2) {
+  checkLists(program1.fragments, program2.fragments, 'fragments',
+      (a, b) => a.outputFileName == b.outputFileName,
+      onSameElement: checkFragments);
+}
+
+// TODO(johnniwinther): Check all fragment properties.
+void checkFragments(Fragment fragment1, Fragment fragment2) {
+  checkLists(fragment1.libraries, fragment2.libraries, 'libraries',
+      (a, b) => a.element.canonicalUri == b.element.canonicalUri,
+      onSameElement: checkLibraries);
+}
+
+// TODO(johnniwinther): Check all library properties.
+void checkLibraries(Library library1, Library library2) {

[Siggi Cherem (dart-lang), 2017/06/23 19:49:28]

suggestion
 - possibly rename to checkEmittedLibraries and checkEmittedClasses below? (just
to make the distinction clear, since the types don't have a namespace.), or
 - add the namespace with a prefix:

   checkClasses(emitter.Class c1, emitter.Class c2) { ... }

[Johnni Winther, 2017/06/26 09:17:44]

Renamed functions to checkEmitter*

+  checkLists(library1.classes, library2.classes, 'classes',
+      (a, b) => a.element.name == b.element.name,
+      onSameElement: checkClasses);
+// TODO(johnniwinther): Check static method properties.
+  checkLists(library1.statics, library2.statics, 'statics',
+      (a, b) => a.name.key == b.name.key);
+}
+
+// TODO(johnniwinther): Check all class properties.
+void checkClasses(Class class1, Class class2) {
+  checkLists(class1.methods, class2.methods, 'methods',
+      (a, b) => a.name.key == b.name.key);
+  checkLists(class1.isChecks, class2.isChecks, 'isChecks',
+      (a, b) => a.name.key == b.name.key);
+}