Enhance precision of recorded instantiation info in ResolutionWorldBuilder

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/dart_types.dart';
 import 'package:compiler/src/deferred_load.dart';
 import 'package:compiler/src/elements/elements.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/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';
 
 /// Number of tests that are not part of the automatic test grouping.
 int SKIP_COUNT = 2;
 
 /// Number of groups that the [TESTS] are split into.
@@ skipping 65 matching lines @@
         compilerNormal.closedWorld, compilerDeserialized.closedWorld,
         verbose: verbose);
     checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
   });
 }
 
 void checkResolutionEnqueuers(
     ResolutionEnqueuer enqueuer1, ResolutionEnqueuer enqueuer2,
     {bool typeEquivalence(DartType a, DartType b): areTypesEquivalent,
     bool elementFilter(Element element),
+    bool checkInstantiatedTypesAndClasses: true,
     bool verbose: false}) {
   Iterable<Element> processedElements1 = enqueuer1.processedElements;
   Iterable<Element> processedElements2 = enqueuer2.processedElements;
   if (elementFilter != null) {
     processedElements1 = processedElements1.where(elementFilter);
     processedElements2 = processedElements2.where(elementFilter);
   }
 
   checkSets(processedElements1, processedElements2,
       "Processed element mismatch", areElementsEquivalent,
       verbose: verbose);
 
-  checkSets(
-      enqueuer1.universe.directlyInstantiatedClasses,
-      enqueuer2.universe.directlyInstantiatedClasses,
-      "Directly instantiated classes mismatch",
+  /// Normalize the instantiation map by removing redirections and converting
+  /// redirecting factories to their effective target.
+  Map<ClassElement, InstantiationInfo> createInstantiationMap(
+      ResolutionWorldBuilder worldBuilder) {
+    Map<ClassElement, InstantiationInfo> instantiationMap =
+        <ClassElement, InstantiationInfo>{};
+
+    InstantiationInfo infoFor(ClassElement cls) {
+      return instantiationMap.putIfAbsent(cls, () => new InstantiationInfo());
+    }
+
+    worldBuilder.forEachInstantiatedClass((cls, info) {
+      if (info.instantiationMap != null) {
+        info.instantiationMap
+            .forEach((ConstructorElement constructor, Set<Instance> set) {
+          for (Instance instance in set) {
+            if (instance.isRedirection) {
+              continue;
+            }
+            if (constructor == null || !constructor.isRedirectingFactory) {
+              infoFor(cls)
+                  .addInstantiation(constructor, instance.type, instance.kind);
+            } else {
+              ConstructorElement target = constructor.effectiveTarget;
+              InterfaceType targetType =
+                  constructor.computeEffectiveTargetType(instance.type);
+              infoFor(targetType.element).addInstantiation(
+                  target, targetType, Instantiation.DIRECTLY_INSTANTIATED);
+            }
+          }
+        });
+      }
+    });
+    return instantiationMap;
+  }
+
+  checkMaps(
+      createInstantiationMap(enqueuer1.universe),
+      createInstantiationMap(enqueuer2.universe),
+      "Instantiated classes mismatch",
       areElementsEquivalent,
+      (a, b) => areInstantiationInfosEquivalent(a, b, typeEquivalence),
       verbose: verbose);
+  if (checkInstantiatedTypesAndClasses) {
+    checkSets(
+        enqueuer1.universe.directlyInstantiatedClasses,
+        enqueuer2.universe.directlyInstantiatedClasses,
+        "Directly instantiated classes mismatch",
+        areElementsEquivalent,
+        verbose: verbose);
 
-  checkSets(
-      enqueuer1.universe.instantiatedTypes,
-      enqueuer2.universe.instantiatedTypes,
-      "Instantiated types mismatch",
-      typeEquivalence,
-      verbose: verbose);
+    checkSets(
+        enqueuer1.universe.instantiatedTypes,
+        enqueuer2.universe.instantiatedTypes,
+        "Instantiated types mismatch",
+        typeEquivalence,
+        verbose: verbose);
+  }
 
   checkSets(enqueuer1.universe.isChecks, enqueuer2.universe.isChecks,
       "Is-check mismatch", typeEquivalence,
       verbose: verbose);
 
   JavaScriptBackend backend1 = enqueuer1.backend;
   JavaScriptBackend backend2 = enqueuer2.backend;
   Expect.equals(backend1.hasInvokeOnSupport, backend2.hasInvokeOnSupport,
       "Compiler.enabledInvokeOn mismatch");
   Expect.equals(
@@ skipping 267 matching lines @@
   check(outputUnit1, outputUnit2, 'OutputUnit.isMainOutput $message',
       outputUnit1.isMainOutput, outputUnit2.isMainOutput);
   checkSetEquivalence(
       outputUnit1,
       outputUnit2,
       'OutputUnit.imports $message',
       outputUnit1.imports,
       outputUnit2.imports,
       (a, b) => areElementsEquivalent(a.declaration, b.declaration));
 }
+
+bool areInstantiationInfosEquivalent(InstantiationInfo info1,
+    InstantiationInfo info2, bool typeEquivalence(DartType a, DartType b)) {
+  checkMaps(
+      info1.instantiationMap,
+      info2.instantiationMap,
+      'instantiationMap of\n   '
+          '${info1.instantiationMap}\nvs ${info2.instantiationMap}',
+      areElementsEquivalent,
+      (a, b) => areSetsEquivalent(
+          a, b, (a, b) => areInstancesEquivalent(a, b, typeEquivalence)));
+  return true;
+}
+
+bool areInstancesEquivalent(Instance instance1, Instance instance2,
+    bool typeEquivalence(DartType a, DartType b)) {
+  return typeEquivalence(instance1.type, instance2.type) &&
+      instance1.kind == instance2.kind &&
+      instance1.isRedirection == instance2.isRedirection;
+}